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 2598.5.8
- compare with another revision
- download diff
- download tarball
- view history from revision 2598.5.8
- Committer: Aaron Bentley
- Date: 2007-07-12 07:37:18 UTC
- mfrom: (2603 +trunk)
- mto: This revision was merged to the branch mainline in revision 2606.
- Revision ID: aaron.bentley@utoronto.ca-20070712073718-255ekb0xllut6jmb
Merge bzr.dev
- files added:
- .bzrignore
- bzrlib
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- 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/interrepository_implementations
- bzrlib/tests/intertree_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/per_lock
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- 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/version_info_formats
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- doc
- doc/developers
- man1
- tools
- tools/doc_generate
- tools/win32
- files removed:
- .bzrignore
- foreign
- notes
- tests
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
2
#
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
#
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
12
#
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
"""builtin bzr commands"""
18
19
import os
20
from StringIO import StringIO
21
22
from bzrlib.lazy_import import lazy_import
23
lazy_import(globals(), """
24
import codecs
25
import errno
26
import sys
27
import tempfile
28
import time
29
30
import bzrlib
31
from bzrlib import (
32
branch,
33
bugtracker,
34
bundle,
35
bzrdir,
36
delta,
37
config,
38
errors,
39
globbing,
40
ignores,
41
log,
42
merge as _mod_merge,
43
merge_directive,
44
osutils,
45
registry,
46
repository,
47
revision as _mod_revision,
48
revisionspec,
49
symbol_versioning,
50
transport,
51
tree as _mod_tree,
52
ui,
53
urlutils,
54
)
55
from bzrlib.branch import Branch
56
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
57
from bzrlib.conflicts import ConflictList
58
from bzrlib.revisionspec import RevisionSpec
59
from bzrlib.smtp_connection import SMTPConnection
60
from bzrlib.workingtree import WorkingTree
61
""")
62
63
from bzrlib.commands import Command, display_command
64
from bzrlib.option import ListOption, Option, RegistryOption
65
from bzrlib.progress import DummyProgress, ProgressPhase
66
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
67
68
69
def tree_files(file_list, default_branch=u'.'):
70
try:
71
return internal_tree_files(file_list, default_branch)
72
except errors.FileInWrongBranch, e:
73
raise errors.BzrCommandError("%s is not in the same branch as %s" %
74
(e.path, file_list[0]))
75
76
77
# XXX: Bad function name; should possibly also be a class method of
78
# WorkingTree rather than a function.
79
def internal_tree_files(file_list, default_branch=u'.'):
80
"""Convert command-line paths to a WorkingTree and relative paths.
81
82
This is typically used for command-line processors that take one or
83
more filenames, and infer the workingtree that contains them.
84
85
The filenames given are not required to exist.
86
87
:param file_list: Filenames to convert.
88
89
:param default_branch: Fallback tree path to use if file_list is empty or
90
None.
91
92
:return: workingtree, [relative_paths]
93
"""
94
if file_list is None or len(file_list) == 0:
95
return WorkingTree.open_containing(default_branch)[0], file_list
96
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
97
new_list = []
98
for filename in file_list:
99
try:
100
new_list.append(tree.relpath(osutils.dereference_path(filename)))
101
except errors.PathNotChild:
102
raise errors.FileInWrongBranch(tree.branch, filename)
103
return tree, new_list
104
105
106
@symbol_versioning.deprecated_function(symbol_versioning.zero_fifteen)
107
def get_format_type(typestring):
108
"""Parse and return a format specifier."""
109
# Have to use BzrDirMetaFormat1 directly, so that
110
# RepositoryFormat.set_default_format works
111
if typestring == "default":
112
return bzrdir.BzrDirMetaFormat1()
113
try:
114
return bzrdir.format_registry.make_bzrdir(typestring)
115
except KeyError:
116
msg = 'Unknown bzr format "%s". See "bzr help formats".' % typestring
117
raise errors.BzrCommandError(msg)
118
119
120
# TODO: Make sure no commands unconditionally use the working directory as a
121
# branch. If a filename argument is used, the first of them should be used to
122
# specify the branch. (Perhaps this can be factored out into some kind of
123
# Argument class, representing a file in a branch, where the first occurrence
124
# opens the branch?)
125
126
class cmd_status(Command):
127
"""Display status summary.
128
129
This reports on versioned and unknown files, reporting them
130
grouped by state. Possible states are:
131
132
added
133
Versioned in the working copy but not in the previous revision.
134
135
removed
136
Versioned in the previous revision but removed or deleted
137
in the working copy.
138
139
renamed
140
Path of this file changed from the previous revision;
141
the text may also have changed. This includes files whose
142
parent directory was renamed.
143
144
modified
145
Text has changed since the previous revision.
146
147
kind changed
148
File kind has been changed (e.g. from file to directory).
149
150
unknown
151
Not versioned and not matching an ignore pattern.
152
153
To see ignored files use 'bzr ignored'. For details on the
154
changes to file texts, use 'bzr diff'.
155
156
--short gives a status flags for each item, similar to the SVN's status
157
command.
158
159
If no arguments are specified, the status of the entire working
160
directory is shown. Otherwise, only the status of the specified
161
files or directories is reported. If a directory is given, status
162
is reported for everything inside that directory.
163
164
If a revision argument is given, the status is calculated against
165
that revision, or between two revisions if two are provided.
166
"""
167
168
# TODO: --no-recurse, --recurse options
169
170
takes_args = ['file*']
171
takes_options = ['show-ids', 'revision',
172
Option('short', help='Give short SVN-style status lines.'),
173
Option('versioned', help='Only show versioned files.')]
174
aliases = ['st', 'stat']
175
176
encoding_type = 'replace'
177
_see_also = ['diff', 'revert', 'status-flags']
178
179
@display_command
180
def run(self, show_ids=False, file_list=None, revision=None, short=False,
181
versioned=False):
182
from bzrlib.status import show_tree_status
183
184
tree, file_list = tree_files(file_list)
185
186
show_tree_status(tree, show_ids=show_ids,
187
specific_files=file_list, revision=revision,
188
to_file=self.outf, short=short, versioned=versioned)
189
190
191
class cmd_cat_revision(Command):
192
"""Write out metadata for a revision.
193
194
The revision to print can either be specified by a specific
195
revision identifier, or you can use --revision.
196
"""
197
198
hidden = True
199
takes_args = ['revision_id?']
200
takes_options = ['revision']
201
# cat-revision is more for frontends so should be exact
202
encoding = 'strict'
203
204
@display_command
205
def run(self, revision_id=None, revision=None):
206
207
revision_id = osutils.safe_revision_id(revision_id, warn=False)
208
if revision_id is not None and revision is not None:
209
raise errors.BzrCommandError('You can only supply one of'
210
' revision_id or --revision')
211
if revision_id is None and revision is None:
212
raise errors.BzrCommandError('You must supply either'
213
' --revision or a revision_id')
214
b = WorkingTree.open_containing(u'.')[0].branch
215
216
# TODO: jam 20060112 should cat-revision always output utf-8?
217
if revision_id is not None:
218
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
219
elif revision is not None:
220
for rev in revision:
221
if rev is None:
222
raise errors.BzrCommandError('You cannot specify a NULL'
223
' revision.')
224
revno, rev_id = rev.in_history(b)
225
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
226
227
228
class cmd_remove_tree(Command):
229
"""Remove the working tree from a given branch/checkout.
230
231
Since a lightweight checkout is little more than a working tree
232
this will refuse to run against one.
233
234
To re-create the working tree, use "bzr checkout".
235
"""
236
_see_also = ['checkout', 'working-trees']
237
238
takes_args = ['location?']
239
240
def run(self, location='.'):
241
d = bzrdir.BzrDir.open(location)
242
243
try:
244
working = d.open_workingtree()
245
except errors.NoWorkingTree:
246
raise errors.BzrCommandError("No working tree to remove")
247
except errors.NotLocalUrl:
248
raise errors.BzrCommandError("You cannot remove the working tree of a "
249
"remote path")
250
251
working_path = working.bzrdir.root_transport.base
252
branch_path = working.branch.bzrdir.root_transport.base
253
if working_path != branch_path:
254
raise errors.BzrCommandError("You cannot remove the working tree from "
255
"a lightweight checkout")
256
257
d.destroy_workingtree()
258
259
260
class cmd_revno(Command):
261
"""Show current revision number.
262
263
This is equal to the number of revisions on this branch.
264
"""
265
266
_see_also = ['info']
267
takes_args = ['location?']
268
269
@display_command
270
def run(self, location=u'.'):
271
self.outf.write(str(Branch.open_containing(location)[0].revno()))
272
self.outf.write('\n')
273
274
275
class cmd_revision_info(Command):
276
"""Show revision number and revision id for a given revision identifier.
277
"""
278
hidden = True
279
takes_args = ['revision_info*']
280
takes_options = ['revision']
281
282
@display_command
283
def run(self, revision=None, revision_info_list=[]):
284
285
revs = []
286
if revision is not None:
287
revs.extend(revision)
288
if revision_info_list is not None:
289
for rev in revision_info_list:
290
revs.append(RevisionSpec.from_string(rev))
291
292
b = Branch.open_containing(u'.')[0]
293
294
if len(revs) == 0:
295
revs.append(RevisionSpec.from_string('-1'))
296
297
for rev in revs:
298
revinfo = rev.in_history(b)
299
if revinfo.revno is None:
300
dotted_map = b.get_revision_id_to_revno_map()
301
revno = '.'.join(str(i) for i in dotted_map[revinfo.rev_id])
302
print '%s %s' % (revno, revinfo.rev_id)
303
else:
304
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
305
306
307
class cmd_add(Command):
308
"""Add specified files or directories.
309
310
In non-recursive mode, all the named items are added, regardless
311
of whether they were previously ignored. A warning is given if
312
any of the named files are already versioned.
313
314
In recursive mode (the default), files are treated the same way
315
but the behaviour for directories is different. Directories that
316
are already versioned do not give a warning. All directories,
317
whether already versioned or not, are searched for files or
318
subdirectories that are neither versioned or ignored, and these
319
are added. This search proceeds recursively into versioned
320
directories. If no names are given '.' is assumed.
321
322
Therefore simply saying 'bzr add' will version all files that
323
are currently unknown.
324
325
Adding a file whose parent directory is not versioned will
326
implicitly add the parent, and so on up to the root. This means
327
you should never need to explicitly add a directory, they'll just
328
get added when you add a file in the directory.
329
330
--dry-run will show which files would be added, but not actually
331
add them.
332
333
--file-ids-from will try to use the file ids from the supplied path.
334
It looks up ids trying to find a matching parent directory with the
335
same filename, and then by pure path. This option is rarely needed
336
but can be useful when adding the same logical file into two
337
branches that will be merged later (without showing the two different
338
adds as a conflict). It is also useful when merging another project
339
into a subdirectory of this one.
340
"""
341
takes_args = ['file*']
342
takes_options = ['no-recurse', 'dry-run', 'verbose',
343
Option('file-ids-from', type=unicode,
344
help='Lookup file ids from this tree.')]
345
encoding_type = 'replace'
346
_see_also = ['remove']
347
348
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
349
file_ids_from=None):
350
import bzrlib.add
351
352
base_tree = None
353
if file_ids_from is not None:
354
try:
355
base_tree, base_path = WorkingTree.open_containing(
356
file_ids_from)
357
except errors.NoWorkingTree:
358
base_branch, base_path = Branch.open_containing(
359
file_ids_from)
360
base_tree = base_branch.basis_tree()
361
362
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
363
to_file=self.outf, should_print=(not is_quiet()))
364
else:
365
action = bzrlib.add.AddAction(to_file=self.outf,
366
should_print=(not is_quiet()))
367
368
if base_tree:
369
base_tree.lock_read()
370
try:
371
file_list = self._maybe_expand_globs(file_list)
372
if file_list:
373
tree = WorkingTree.open_containing(file_list[0])[0]
374
else:
375
tree = WorkingTree.open_containing(u'.')[0]
376
added, ignored = tree.smart_add(file_list, not
377
no_recurse, action=action, save=not dry_run)
378
finally:
379
if base_tree is not None:
380
base_tree.unlock()
381
if len(ignored) > 0:
382
if verbose:
383
for glob in sorted(ignored.keys()):
384
for path in ignored[glob]:
385
self.outf.write("ignored %s matching \"%s\"\n"
386
% (path, glob))
387
else:
388
match_len = 0
389
for glob, paths in ignored.items():
390
match_len += len(paths)
391
self.outf.write("ignored %d file(s).\n" % match_len)
392
self.outf.write("If you wish to add some of these files,"
393
" please add them by name.\n")
394
395
396
class cmd_mkdir(Command):
397
"""Create a new versioned directory.
398
399
This is equivalent to creating the directory and then adding it.
400
"""
401
402
takes_args = ['dir+']
403
encoding_type = 'replace'
404
405
def run(self, dir_list):
406
for d in dir_list:
407
os.mkdir(d)
408
wt, dd = WorkingTree.open_containing(d)
409
wt.add([dd])
410
self.outf.write('added %s\n' % d)
411
412
413
class cmd_relpath(Command):
414
"""Show path of a file relative to root"""
415
416
takes_args = ['filename']
417
hidden = True
418
419
@display_command
420
def run(self, filename):
421
# TODO: jam 20050106 Can relpath return a munged path if
422
# sys.stdout encoding cannot represent it?
423
tree, relpath = WorkingTree.open_containing(filename)
424
self.outf.write(relpath)
425
self.outf.write('\n')
426
427
428
class cmd_inventory(Command):
429
"""Show inventory of the current working copy or a revision.
430
431
It is possible to limit the output to a particular entry
432
type using the --kind option. For example: --kind file.
433
434
It is also possible to restrict the list of files to a specific
435
set. For example: bzr inventory --show-ids this/file
436
"""
437
438
hidden = True
439
_see_also = ['ls']
440
takes_options = ['revision', 'show-ids', 'kind']
441
takes_args = ['file*']
442
443
@display_command
444
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
445
if kind and kind not in ['file', 'directory', 'symlink']:
446
raise errors.BzrCommandError('invalid kind specified')
447
448
work_tree, file_list = tree_files(file_list)
449
work_tree.lock_read()
450
try:
451
if revision is not None:
452
if len(revision) > 1:
453
raise errors.BzrCommandError(
454
'bzr inventory --revision takes exactly one revision'
455
' identifier')
456
revision_id = revision[0].in_history(work_tree.branch).rev_id
457
tree = work_tree.branch.repository.revision_tree(revision_id)
458
459
extra_trees = [work_tree]
460
tree.lock_read()
461
else:
462
tree = work_tree
463
extra_trees = []
464
465
if file_list is not None:
466
file_ids = tree.paths2ids(file_list, trees=extra_trees,
467
require_versioned=True)
468
# find_ids_across_trees may include some paths that don't
469
# exist in 'tree'.
470
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
471
for file_id in file_ids if file_id in tree)
472
else:
473
entries = tree.inventory.entries()
474
finally:
475
tree.unlock()
476
if tree is not work_tree:
477
work_tree.unlock()
478
479
for path, entry in entries:
480
if kind and kind != entry.kind:
481
continue
482
if show_ids:
483
self.outf.write('%-50s %s\n' % (path, entry.file_id))
484
else:
485
self.outf.write(path)
486
self.outf.write('\n')
487
488
489
class cmd_mv(Command):
490
"""Move or rename a file.
491
492
usage:
493
bzr mv OLDNAME NEWNAME
494
bzr mv SOURCE... DESTINATION
495
496
If the last argument is a versioned directory, all the other names
497
are moved into it. Otherwise, there must be exactly two arguments
498
and the file is changed to a new name.
499
500
If OLDNAME does not exist on the filesystem but is versioned and
501
NEWNAME does exist on the filesystem but is not versioned, mv
502
assumes that the file has been manually moved and only updates
503
its internal inventory to reflect that change.
504
The same is valid when moving many SOURCE files to a DESTINATION.
505
506
Files cannot be moved between branches.
507
"""
508
509
takes_args = ['names*']
510
takes_options = [Option("after", help="Move only the bzr identifier"
511
" of the file, because the file has already been moved."),
512
]
513
aliases = ['move', 'rename']
514
encoding_type = 'replace'
515
516
def run(self, names_list, after=False):
517
if names_list is None:
518
names_list = []
519
520
if len(names_list) < 2:
521
raise errors.BzrCommandError("missing file argument")
522
tree, rel_names = tree_files(names_list)
523
524
if os.path.isdir(names_list[-1]):
525
# move into existing directory
526
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
527
self.outf.write("%s => %s\n" % pair)
528
else:
529
if len(names_list) != 2:
530
raise errors.BzrCommandError('to mv multiple files the'
531
' destination must be a versioned'
532
' directory')
533
tree.rename_one(rel_names[0], rel_names[1], after=after)
534
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
535
536
537
class cmd_pull(Command):
538
"""Turn this branch into a mirror of another branch.
539
540
This command only works on branches that have not diverged. Branches are
541
considered diverged if the destination branch's most recent commit is one
542
that has not been merged (directly or indirectly) into the parent.
543
544
If branches have diverged, you can use 'bzr merge' to integrate the changes
545
from one into the other. Once one branch has merged, the other should
546
be able to pull it again.
547
548
If you want to forget your local changes and just update your branch to
549
match the remote one, use pull --overwrite.
550
551
If there is no default location set, the first pull will set it. After
552
that, you can omit the location to use the default. To change the
553
default, use --remember. The value will only be saved if the remote
554
location can be accessed.
555
"""
556
557
_see_also = ['push', 'update', 'status-flags']
558
takes_options = ['remember', 'overwrite', 'revision', 'verbose',
559
Option('directory',
560
help='Branch to pull into, '
561
'rather than the one containing the working directory.',
562
short_name='d',
563
type=unicode,
564
),
565
]
566
takes_args = ['location?']
567
encoding_type = 'replace'
568
569
def run(self, location=None, remember=False, overwrite=False,
570
revision=None, verbose=False,
571
directory=None):
572
from bzrlib.tag import _merge_tags_if_possible
573
# FIXME: too much stuff is in the command class
574
revision_id = None
575
mergeable = None
576
if directory is None:
577
directory = u'.'
578
try:
579
tree_to = WorkingTree.open_containing(directory)[0]
580
branch_to = tree_to.branch
581
except errors.NoWorkingTree:
582
tree_to = None
583
branch_to = Branch.open_containing(directory)[0]
584
585
reader = None
586
if location is not None:
587
try:
588
mergeable = bundle.read_mergeable_from_url(
589
location)
590
except errors.NotABundle:
591
pass # Continue on considering this url a Branch
592
593
stored_loc = branch_to.get_parent()
594
if location is None:
595
if stored_loc is None:
596
raise errors.BzrCommandError("No pull location known or"
597
" specified.")
598
else:
599
display_url = urlutils.unescape_for_display(stored_loc,
600
self.outf.encoding)
601
self.outf.write("Using saved location: %s\n" % display_url)
602
location = stored_loc
603
604
if mergeable is not None:
605
if revision is not None:
606
raise errors.BzrCommandError(
607
'Cannot use -r with merge directives or bundles')
608
revision_id = mergeable.install_revisions(branch_to.repository)
609
branch_from = branch_to
610
else:
611
branch_from = Branch.open(location)
612
613
if branch_to.get_parent() is None or remember:
614
branch_to.set_parent(branch_from.base)
615
616
if revision is not None:
617
if len(revision) == 1:
618
revision_id = revision[0].in_history(branch_from).rev_id
619
else:
620
raise errors.BzrCommandError(
621
'bzr pull --revision takes one value.')
622
623
old_rh = branch_to.revision_history()
624
if tree_to is not None:
625
result = tree_to.pull(branch_from, overwrite, revision_id,
626
delta._ChangeReporter(unversioned_filter=tree_to.is_ignored))
627
else:
628
result = branch_to.pull(branch_from, overwrite, revision_id)
629
630
result.report(self.outf)
631
if verbose:
632
from bzrlib.log import show_changed_revisions
633
new_rh = branch_to.revision_history()
634
show_changed_revisions(branch_to, old_rh, new_rh,
635
to_file=self.outf)
636
637
638
class cmd_push(Command):
639
"""Update a mirror of this branch.
640
641
The target branch will not have its working tree populated because this
642
is both expensive, and is not supported on remote file systems.
643
644
Some smart servers or protocols *may* put the working tree in place in
645
the future.
646
647
This command only works on branches that have not diverged. Branches are
648
considered diverged if the destination branch's most recent commit is one
649
that has not been merged (directly or indirectly) by the source branch.
650
651
If branches have diverged, you can use 'bzr push --overwrite' to replace
652
the other branch completely, discarding its unmerged changes.
653
654
If you want to ensure you have the different changes in the other branch,
655
do a merge (see bzr help merge) from the other branch, and commit that.
656
After that you will be able to do a push without '--overwrite'.
657
658
If there is no default push location set, the first push will set it.
659
After that, you can omit the location to use the default. To change the
660
default, use --remember. The value will only be saved if the remote
661
location can be accessed.
662
"""
663
664
_see_also = ['pull', 'update', 'working-trees']
665
takes_options = ['remember', 'overwrite', 'verbose',
666
Option('create-prefix',
667
help='Create the path leading up to the branch '
668
'if it does not already exist.'),
669
Option('directory',
670
help='Branch to push from, '
671
'rather than the one containing the working directory.',
672
short_name='d',
673
type=unicode,
674
),
675
Option('use-existing-dir',
676
help='By default push will fail if the target'
677
' directory exists, but does not already'
678
' have a control directory. This flag will'
679
' allow push to proceed.'),
680
]
681
takes_args = ['location?']
682
encoding_type = 'replace'
683
684
def run(self, location=None, remember=False, overwrite=False,
685
create_prefix=False, verbose=False,
686
use_existing_dir=False,
687
directory=None):
688
# FIXME: Way too big! Put this into a function called from the
689
# command.
690
if directory is None:
691
directory = '.'
692
br_from = Branch.open_containing(directory)[0]
693
stored_loc = br_from.get_push_location()
694
if location is None:
695
if stored_loc is None:
696
raise errors.BzrCommandError("No push location known or specified.")
697
else:
698
display_url = urlutils.unescape_for_display(stored_loc,
699
self.outf.encoding)
700
self.outf.write("Using saved location: %s\n" % display_url)
701
location = stored_loc
702
703
to_transport = transport.get_transport(location)
704
705
br_to = repository_to = dir_to = None
706
try:
707
dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
708
except errors.NotBranchError:
709
pass # Didn't find anything
710
else:
711
# If we can open a branch, use its direct repository, otherwise see
712
# if there is a repository without a branch.
713
try:
714
br_to = dir_to.open_branch()
715
except errors.NotBranchError:
716
# Didn't find a branch, can we find a repository?
717
try:
718
repository_to = dir_to.find_repository()
719
except errors.NoRepositoryPresent:
720
pass
721
else:
722
# Found a branch, so we must have found a repository
723
repository_to = br_to.repository
724
push_result = None
725
old_rh = []
726
if dir_to is None:
727
# The destination doesn't exist; create it.
728
# XXX: Refactor the create_prefix/no_create_prefix code into a
729
# common helper function
730
try:
731
to_transport.mkdir('.')
732
except errors.FileExists:
733
if not use_existing_dir:
734
raise errors.BzrCommandError("Target directory %s"
735
" already exists, but does not have a valid .bzr"
736
" directory. Supply --use-existing-dir to push"
737
" there anyway." % location)
738
except errors.NoSuchFile:
739
if not create_prefix:
740
raise errors.BzrCommandError("Parent directory of %s"
741
" does not exist."
742
"\nYou may supply --create-prefix to create all"
743
" leading parent directories."
744
% location)
745
746
_create_prefix(to_transport)
747
748
# Now the target directory exists, but doesn't have a .bzr
749
# directory. So we need to create it, along with any work to create
750
# all of the dependent branches, etc.
751
dir_to = br_from.bzrdir.clone_on_transport(to_transport,
752
revision_id=br_from.last_revision())
753
br_to = dir_to.open_branch()
754
# TODO: Some more useful message about what was copied
755
note('Created new branch.')
756
# We successfully created the target, remember it
757
if br_from.get_push_location() is None or remember:
758
br_from.set_push_location(br_to.base)
759
elif repository_to is None:
760
# we have a bzrdir but no branch or repository
761
# XXX: Figure out what to do other than complain.
762
raise errors.BzrCommandError("At %s you have a valid .bzr control"
763
" directory, but not a branch or repository. This is an"
764
" unsupported configuration. Please move the target directory"
765
" out of the way and try again."
766
% location)
767
elif br_to is None:
768
# We have a repository but no branch, copy the revisions, and then
769
# create a branch.
770
last_revision_id = br_from.last_revision()
771
repository_to.fetch(br_from.repository,
772
revision_id=last_revision_id)
773
br_to = br_from.clone(dir_to, revision_id=last_revision_id)
774
note('Created new branch.')
775
if br_from.get_push_location() is None or remember:
776
br_from.set_push_location(br_to.base)
777
else: # We have a valid to branch
778
# We were able to connect to the remote location, so remember it
779
# we don't need to successfully push because of possible divergence.
780
if br_from.get_push_location() is None or remember:
781
br_from.set_push_location(br_to.base)
782
old_rh = br_to.revision_history()
783
try:
784
try:
785
tree_to = dir_to.open_workingtree()
786
except errors.NotLocalUrl:
787
warning("This transport does not update the working "
788
"tree of: %s. See 'bzr help working-trees' for "
789
"more information." % br_to.base)
790
push_result = br_from.push(br_to, overwrite)
791
except errors.NoWorkingTree:
792
push_result = br_from.push(br_to, overwrite)
793
else:
794
tree_to.lock_write()
795
try:
796
push_result = br_from.push(tree_to.branch, overwrite)
797
tree_to.update()
798
finally:
799
tree_to.unlock()
800
except errors.DivergedBranches:
801
raise errors.BzrCommandError('These branches have diverged.'
802
' Try using "merge" and then "push".')
803
if push_result is not None:
804
push_result.report(self.outf)
805
elif verbose:
806
new_rh = br_to.revision_history()
807
if old_rh != new_rh:
808
# Something changed
809
from bzrlib.log import show_changed_revisions
810
show_changed_revisions(br_to, old_rh, new_rh,
811
to_file=self.outf)
812
else:
813
# we probably did a clone rather than a push, so a message was
814
# emitted above
815
pass
816
817
818
class cmd_branch(Command):
819
"""Create a new copy of a branch.
820
821
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
822
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
823
If the FROM_LOCATION has no / or path separator embedded, the TO_LOCATION
824
is derived from the FROM_LOCATION by stripping a leading scheme or drive
825
identifier, if any. For example, "branch lp:foo-bar" will attempt to
826
create ./foo-bar.
827
828
To retrieve the branch as of a particular revision, supply the --revision
829
parameter, as in "branch foo/bar -r 5".
830
"""
831
832
_see_also = ['checkout']
833
takes_args = ['from_location', 'to_location?']
834
takes_options = ['revision']
835
aliases = ['get', 'clone']
836
837
def run(self, from_location, to_location=None, revision=None):
838
from bzrlib.tag import _merge_tags_if_possible
839
if revision is None:
840
revision = [None]
841
elif len(revision) > 1:
842
raise errors.BzrCommandError(
843
'bzr branch --revision takes exactly 1 revision value')
844
845
br_from = Branch.open(from_location)
846
br_from.lock_read()
847
try:
848
if len(revision) == 1 and revision[0] is not None:
849
revision_id = revision[0].in_history(br_from)[1]
850
else:
851
# FIXME - wt.last_revision, fallback to branch, fall back to
852
# None or perhaps NULL_REVISION to mean copy nothing
853
# RBC 20060209
854
revision_id = br_from.last_revision()
855
if to_location is None:
856
to_location = urlutils.derive_to_location(from_location)
857
name = None
858
else:
859
name = os.path.basename(to_location) + '\n'
860
861
to_transport = transport.get_transport(to_location)
862
try:
863
to_transport.mkdir('.')
864
except errors.FileExists:
865
raise errors.BzrCommandError('Target directory "%s" already'
866
' exists.' % to_location)
867
except errors.NoSuchFile:
868
raise errors.BzrCommandError('Parent of "%s" does not exist.'
869
% to_location)
870
try:
871
# preserve whatever source format we have.
872
dir = br_from.bzrdir.sprout(to_transport.base, revision_id)
873
branch = dir.open_branch()
874
except errors.NoSuchRevision:
875
to_transport.delete_tree('.')
876
msg = "The branch %s has no revision %s." % (from_location, revision[0])
877
raise errors.BzrCommandError(msg)
878
if name:
879
branch.control_files.put_utf8('branch-name', name)
880
_merge_tags_if_possible(br_from, branch)
881
note('Branched %d revision(s).' % branch.revno())
882
finally:
883
br_from.unlock()
884
885
886
class cmd_checkout(Command):
887
"""Create a new checkout of an existing branch.
888
889
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
890
the branch found in '.'. This is useful if you have removed the working tree
891
or if it was never created - i.e. if you pushed the branch to its current
892
location using SFTP.
893
894
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
895
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
896
If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
897
is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
898
identifier, if any. For example, "checkout lp:foo-bar" will attempt to
899
create ./foo-bar.
900
901
To retrieve the branch as of a particular revision, supply the --revision
902
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
903
out of date [so you cannot commit] but it may be useful (i.e. to examine old
904
code.)
905
"""
906
907
_see_also = ['checkouts', 'branch']
908
takes_args = ['branch_location?', 'to_location?']
909
takes_options = ['revision',
910
Option('lightweight',
911
help="Perform a lightweight checkout. Lightweight "
912
"checkouts depend on access to the branch for "
913
"every operation. Normal checkouts can perform "
914
"common operations like diff and status without "
915
"such access, and also support local commits."
916
),
917
]
918
aliases = ['co']
919
920
def run(self, branch_location=None, to_location=None, revision=None,
921
lightweight=False):
922
if revision is None:
923
revision = [None]
924
elif len(revision) > 1:
925
raise errors.BzrCommandError(
926
'bzr checkout --revision takes exactly 1 revision value')
927
if branch_location is None:
928
branch_location = osutils.getcwd()
929
to_location = branch_location
930
source = Branch.open(branch_location)
931
if len(revision) == 1 and revision[0] is not None:
932
revision_id = revision[0].in_history(source)[1]
933
else:
934
revision_id = None
935
if to_location is None:
936
to_location = urlutils.derive_to_location(branch_location)
937
# if the source and to_location are the same,
938
# and there is no working tree,
939
# then reconstitute a branch
940
if (osutils.abspath(to_location) ==
941
osutils.abspath(branch_location)):
942
try:
943
source.bzrdir.open_workingtree()
944
except errors.NoWorkingTree:
945
source.bzrdir.create_workingtree()
946
return
947
try:
948
os.mkdir(to_location)
949
except OSError, e:
950
if e.errno == errno.EEXIST:
951
raise errors.BzrCommandError('Target directory "%s" already'
952
' exists.' % to_location)
953
if e.errno == errno.ENOENT:
954
raise errors.BzrCommandError('Parent of "%s" does not exist.'
955
% to_location)
956
else:
957
raise
958
source.create_checkout(to_location, revision_id, lightweight)
959
960
961
class cmd_renames(Command):
962
"""Show list of renamed files.
963
"""
964
# TODO: Option to show renames between two historical versions.
965
966
# TODO: Only show renames under dir, rather than in the whole branch.
967
_see_also = ['status']
968
takes_args = ['dir?']
969
970
@display_command
971
def run(self, dir=u'.'):
972
tree = WorkingTree.open_containing(dir)[0]
973
tree.lock_read()
974
try:
975
new_inv = tree.inventory
976
old_tree = tree.basis_tree()
977
old_tree.lock_read()
978
try:
979
old_inv = old_tree.inventory
980
renames = list(_mod_tree.find_renames(old_inv, new_inv))
981
renames.sort()
982
for old_name, new_name in renames:
983
self.outf.write("%s => %s\n" % (old_name, new_name))
984
finally:
985
old_tree.unlock()
986
finally:
987
tree.unlock()
988
989
990
class cmd_update(Command):
991
"""Update a tree to have the latest code committed to its branch.
992
993
This will perform a merge into the working tree, and may generate
994
conflicts. If you have any local changes, you will still
995
need to commit them after the update for the update to be complete.
996
997
If you want to discard your local changes, you can just do a
998
'bzr revert' instead of 'bzr commit' after the update.
999
"""
1000
1001
_see_also = ['pull', 'working-trees']
1002
takes_args = ['dir?']
1003
aliases = ['up']
1004
1005
def run(self, dir='.'):
1006
tree = WorkingTree.open_containing(dir)[0]
1007
master = tree.branch.get_master_branch()
1008
if master is not None:
1009
tree.lock_write()
1010
else:
1011
tree.lock_tree_write()
1012
try:
1013
existing_pending_merges = tree.get_parent_ids()[1:]
1014
last_rev = _mod_revision.ensure_null(tree.last_revision())
1015
if last_rev == _mod_revision.ensure_null(
1016
tree.branch.last_revision()):
1017
# may be up to date, check master too.
1018
master = tree.branch.get_master_branch()
1019
if master is None or last_rev == _mod_revision.ensure_null(
1020
master.last_revision()):
1021
revno = tree.branch.revision_id_to_revno(last_rev)
1022
note("Tree is up to date at revision %d." % (revno,))
1023
return 0
1024
conflicts = tree.update(delta._ChangeReporter(
1025
unversioned_filter=tree.is_ignored))
1026
revno = tree.branch.revision_id_to_revno(
1027
_mod_revision.ensure_null(tree.last_revision()))
1028
note('Updated to revision %d.' % (revno,))
1029
if tree.get_parent_ids()[1:] != existing_pending_merges:
1030
note('Your local commits will now show as pending merges with '
1031
"'bzr status', and can be committed with 'bzr commit'.")
1032
if conflicts != 0:
1033
return 1
1034
else:
1035
return 0
1036
finally:
1037
tree.unlock()
1038
1039
1040
class cmd_info(Command):
1041
"""Show information about a working tree, branch or repository.
1042
1043
This command will show all known locations and formats associated to the
1044
tree, branch or repository. Statistical information is included with
1045
each report.
1046
1047
Branches and working trees will also report any missing revisions.
1048
"""
1049
_see_also = ['revno', 'working-trees', 'repositories']
1050
takes_args = ['location?']
1051
takes_options = ['verbose']
1052
1053
@display_command
1054
def run(self, location=None, verbose=0):
1055
from bzrlib.info import show_bzrdir_info
1056
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1057
verbose=verbose)
1058
1059
1060
class cmd_remove(Command):
1061
"""Remove files or directories.
1062
1063
This makes bzr stop tracking changes to the specified files and
1064
delete them if they can easily be recovered using revert.
1065
1066
You can specify one or more files, and/or --new. If you specify --new,
1067
only 'added' files will be removed. If you specify both, then new files
1068
in the specified directories will be removed. If the directories are
1069
also new, they will also be removed.
1070
"""
1071
takes_args = ['file*']
1072
takes_options = ['verbose',
1073
Option('new', help='Remove newly-added files.'),
1074
RegistryOption.from_kwargs('file-deletion-strategy',
1075
'The file deletion mode to be used',
1076
title='Deletion Strategy', value_switches=True, enum_switch=False,
1077
safe='Only delete files if they can be'
1078
' safely recovered (default).',
1079
keep="Don't delete any files.",
1080
force='Delete all the specified files, even if they can not be '
1081
'recovered and even if they are non-empty directories.')]
1082
aliases = ['rm']
1083
encoding_type = 'replace'
1084
1085
def run(self, file_list, verbose=False, new=False,
1086
file_deletion_strategy='safe'):
1087
tree, file_list = tree_files(file_list)
1088
1089
if file_list is not None:
1090
file_list = [f for f in file_list if f != '']
1091
elif not new:
1092
raise errors.BzrCommandError('Specify one or more files to'
1093
' remove, or use --new.')
1094
1095
if new:
1096
added = tree.changes_from(tree.basis_tree(),
1097
specific_files=file_list).added
1098
file_list = sorted([f[0] for f in added], reverse=True)
1099
if len(file_list) == 0:
1100
raise errors.BzrCommandError('No matching files.')
1101
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1102
keep_files=file_deletion_strategy=='keep',
1103
force=file_deletion_strategy=='force')
1104
1105
1106
class cmd_file_id(Command):
1107
"""Print file_id of a particular file or directory.
1108
1109
The file_id is assigned when the file is first added and remains the
1110
same through all revisions where the file exists, even when it is
1111
moved or renamed.
1112
"""
1113
1114
hidden = True
1115
_see_also = ['inventory', 'ls']
1116
takes_args = ['filename']
1117
1118
@display_command
1119
def run(self, filename):
1120
tree, relpath = WorkingTree.open_containing(filename)
1121
i = tree.path2id(relpath)
1122
if i is None:
1123
raise errors.NotVersionedError(filename)
1124
else:
1125
self.outf.write(i + '\n')
1126
1127
1128
class cmd_file_path(Command):
1129
"""Print path of file_ids to a file or directory.
1130
1131
This prints one line for each directory down to the target,
1132
starting at the branch root.
1133
"""
1134
1135
hidden = True
1136
takes_args = ['filename']
1137
1138
@display_command
1139
def run(self, filename):
1140
tree, relpath = WorkingTree.open_containing(filename)
1141
fid = tree.path2id(relpath)
1142
if fid is None:
1143
raise errors.NotVersionedError(filename)
1144
segments = osutils.splitpath(relpath)
1145
for pos in range(1, len(segments) + 1):
1146
path = osutils.joinpath(segments[:pos])
1147
self.outf.write("%s\n" % tree.path2id(path))
1148
1149
1150
class cmd_reconcile(Command):
1151
"""Reconcile bzr metadata in a branch.
1152
1153
This can correct data mismatches that may have been caused by
1154
previous ghost operations or bzr upgrades. You should only
1155
need to run this command if 'bzr check' or a bzr developer
1156
advises you to run it.
1157
1158
If a second branch is provided, cross-branch reconciliation is
1159
also attempted, which will check that data like the tree root
1160
id which was not present in very early bzr versions is represented
1161
correctly in both branches.
1162
1163
At the same time it is run it may recompress data resulting in
1164
a potential saving in disk space or performance gain.
1165
1166
The branch *MUST* be on a listable system such as local disk or sftp.
1167
"""
1168
1169
_see_also = ['check']
1170
takes_args = ['branch?']
1171
1172
def run(self, branch="."):
1173
from bzrlib.reconcile import reconcile
1174
dir = bzrdir.BzrDir.open(branch)
1175
reconcile(dir)
1176
1177
1178
class cmd_revision_history(Command):
1179
"""Display the list of revision ids on a branch."""
1180
1181
_see_also = ['log']
1182
takes_args = ['location?']
1183
1184
hidden = True
1185
1186
@display_command
1187
def run(self, location="."):
1188
branch = Branch.open_containing(location)[0]
1189
for revid in branch.revision_history():
1190
self.outf.write(revid)
1191
self.outf.write('\n')
1192
1193
1194
class cmd_ancestry(Command):
1195
"""List all revisions merged into this branch."""
1196
1197
_see_also = ['log', 'revision-history']
1198
takes_args = ['location?']
1199
1200
hidden = True
1201
1202
@display_command
1203
def run(self, location="."):
1204
try:
1205
wt = WorkingTree.open_containing(location)[0]
1206
except errors.NoWorkingTree:
1207
b = Branch.open(location)
1208
last_revision = b.last_revision()
1209
else:
1210
b = wt.branch
1211
last_revision = wt.last_revision()
1212
1213
revision_ids = b.repository.get_ancestry(last_revision)
1214
assert revision_ids[0] is None
1215
revision_ids.pop(0)
1216
for revision_id in revision_ids:
1217
self.outf.write(revision_id + '\n')
1218
1219
1220
class cmd_init(Command):
1221
"""Make a directory into a versioned branch.
1222
1223
Use this to create an empty branch, or before importing an
1224
existing project.
1225
1226
If there is a repository in a parent directory of the location, then
1227
the history of the branch will be stored in the repository. Otherwise
1228
init creates a standalone branch which carries its own history
1229
in the .bzr directory.
1230
1231
If there is already a branch at the location but it has no working tree,
1232
the tree can be populated with 'bzr checkout'.
1233
1234
Recipe for importing a tree of files:
1235
cd ~/project
1236
bzr init
1237
bzr add .
1238
bzr status
1239
bzr commit -m 'imported project'
1240
"""
1241
1242
_see_also = ['init-repo', 'branch', 'checkout']
1243
takes_args = ['location?']
1244
takes_options = [
1245
Option('create-prefix',
1246
help='Create the path leading up to the branch '
1247
'if it does not already exist.'),
1248
RegistryOption('format',
1249
help='Specify a format for this branch. '
1250
'See "help formats".',
1251
registry=bzrdir.format_registry,
1252
converter=bzrdir.format_registry.make_bzrdir,
1253
value_switches=True,
1254
title="Branch Format",
1255
),
1256
Option('append-revisions-only',
1257
help='Never change revnos or the existing log.'
1258
' Append revisions to it only.')
1259
]
1260
def run(self, location=None, format=None, append_revisions_only=False,
1261
create_prefix=False):
1262
if format is None:
1263
format = bzrdir.format_registry.make_bzrdir('default')
1264
if location is None:
1265
location = u'.'
1266
1267
to_transport = transport.get_transport(location)
1268
1269
# The path has to exist to initialize a
1270
# branch inside of it.
1271
# Just using os.mkdir, since I don't
1272
# believe that we want to create a bunch of
1273
# locations if the user supplies an extended path
1274
try:
1275
to_transport.ensure_base()
1276
except errors.NoSuchFile:
1277
if not create_prefix:
1278
raise errors.BzrCommandError("Parent directory of %s"
1279
" does not exist."
1280
"\nYou may supply --create-prefix to create all"
1281
" leading parent directories."
1282
% location)
1283
_create_prefix(to_transport)
1284
1285
try:
1286
existing_bzrdir = bzrdir.BzrDir.open(location)
1287
except errors.NotBranchError:
1288
# really a NotBzrDir error...
1289
branch = bzrdir.BzrDir.create_branch_convenience(to_transport.base,
1290
format=format)
1291
else:
1292
from bzrlib.transport.local import LocalTransport
1293
if existing_bzrdir.has_branch():
1294
if (isinstance(to_transport, LocalTransport)
1295
and not existing_bzrdir.has_workingtree()):
1296
raise errors.BranchExistsWithoutWorkingTree(location)
1297
raise errors.AlreadyBranchError(location)
1298
else:
1299
branch = existing_bzrdir.create_branch()
1300
existing_bzrdir.create_workingtree()
1301
if append_revisions_only:
1302
try:
1303
branch.set_append_revisions_only(True)
1304
except errors.UpgradeRequired:
1305
raise errors.BzrCommandError('This branch format cannot be set'
1306
' to append-revisions-only. Try --experimental-branch6')
1307
1308
1309
class cmd_init_repository(Command):
1310
"""Create a shared repository to hold branches.
1311
1312
New branches created under the repository directory will store their
1313
revisions in the repository, not in the branch directory.
1314
1315
If the --no-trees option is used then the branches in the repository
1316
will not have working trees by default.
1317
1318
example:
1319
bzr init-repo --no-trees repo
1320
bzr init repo/trunk
1321
bzr checkout --lightweight repo/trunk trunk-checkout
1322
cd trunk-checkout
1323
(add files here)
1324
1325
See 'bzr help repositories' for more information.
1326
"""
1327
1328
_see_also = ['init', 'branch', 'checkout']
1329
takes_args = ["location"]
1330
takes_options = [RegistryOption('format',
1331
help='Specify a format for this repository. See'
1332
' "bzr help formats" for details.',
1333
registry=bzrdir.format_registry,
1334
converter=bzrdir.format_registry.make_bzrdir,
1335
value_switches=True, title='Repository format'),
1336
Option('no-trees',
1337
help='Branches in the repository will default to'
1338
' not having a working tree.'),
1339
]
1340
aliases = ["init-repo"]
1341
1342
def run(self, location, format=None, no_trees=False):
1343
if format is None:
1344
format = bzrdir.format_registry.make_bzrdir('default')
1345
1346
if location is None:
1347
location = '.'
1348
1349
to_transport = transport.get_transport(location)
1350
to_transport.ensure_base()
1351
1352
newdir = format.initialize_on_transport(to_transport)
1353
repo = newdir.create_repository(shared=True)
1354
repo.set_make_working_trees(not no_trees)
1355
1356
1357
class cmd_diff(Command):
1358
"""Show differences in the working tree or between revisions.
1359
1360
If files are listed, only the changes in those files are listed.
1361
Otherwise, all changes for the tree are listed.
1362
1363
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1364
produces patches suitable for "patch -p1".
1365
1366
examples:
1367
bzr diff
1368
Shows the difference in the working tree versus the last commit
1369
bzr diff -r1
1370
Difference between the working tree and revision 1
1371
bzr diff -r1..2
1372
Difference between revision 2 and revision 1
1373
bzr diff --prefix old/:new/
1374
Same as 'bzr diff' but prefix paths with old/ and new/
1375
bzr diff bzr.mine bzr.dev
1376
Show the differences between the two working trees
1377
bzr diff foo.c
1378
Show just the differences for 'foo.c'
1379
"""
1380
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1381
# or a graphical diff.
1382
1383
# TODO: Python difflib is not exactly the same as unidiff; should
1384
# either fix it up or prefer to use an external diff.
1385
1386
# TODO: Selected-file diff is inefficient and doesn't show you
1387
# deleted files.
1388
1389
# TODO: This probably handles non-Unix newlines poorly.
1390
1391
_see_also = ['status']
1392
takes_args = ['file*']
1393
takes_options = ['revision', 'diff-options',
1394
Option('prefix', type=str,
1395
short_name='p',
1396
help='Set prefixes to added to old and new filenames, as '
1397
'two values separated by a colon. (eg "old/:new/").'),
1398
]
1399
aliases = ['di', 'dif']
1400
encoding_type = 'exact'
1401
1402
@display_command
1403
def run(self, revision=None, file_list=None, diff_options=None,
1404
prefix=None):
1405
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1406
1407
if (prefix is None) or (prefix == '0'):
1408
# diff -p0 format
1409
old_label = ''
1410
new_label = ''
1411
elif prefix == '1':
1412
old_label = 'old/'
1413
new_label = 'new/'
1414
elif ':' in prefix:
1415
old_label, new_label = prefix.split(":")
1416
else:
1417
raise errors.BzrCommandError(
1418
'--prefix expects two values separated by a colon'
1419
' (eg "old/:new/")')
1420
1421
if revision and len(revision) > 2:
1422
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1423
' one or two revision specifiers')
1424
1425
try:
1426
tree1, file_list = internal_tree_files(file_list)
1427
tree2 = None
1428
b = None
1429
b2 = None
1430
except errors.FileInWrongBranch:
1431
if len(file_list) != 2:
1432
raise errors.BzrCommandError("Files are in different branches")
1433
1434
tree1, file1 = WorkingTree.open_containing(file_list[0])
1435
tree2, file2 = WorkingTree.open_containing(file_list[1])
1436
if file1 != "" or file2 != "":
1437
# FIXME diff those two files. rbc 20051123
1438
raise errors.BzrCommandError("Files are in different branches")
1439
file_list = None
1440
except errors.NotBranchError:
1441
if (revision is not None and len(revision) == 2
1442
and not revision[0].needs_branch()
1443
and not revision[1].needs_branch()):
1444
# If both revision specs include a branch, we can
1445
# diff them without needing a local working tree
1446
tree1, tree2 = None, None
1447
else:
1448
raise
1449
1450
if tree2 is not None:
1451
if revision is not None:
1452
# FIXME: but there should be a clean way to diff between
1453
# non-default versions of two trees, it's not hard to do
1454
# internally...
1455
raise errors.BzrCommandError(
1456
"Sorry, diffing arbitrary revisions across branches "
1457
"is not implemented yet")
1458
return show_diff_trees(tree1, tree2, sys.stdout,
1459
specific_files=file_list,
1460
external_diff_options=diff_options,
1461
old_label=old_label, new_label=new_label)
1462
1463
return diff_cmd_helper(tree1, file_list, diff_options,
1464
revision_specs=revision,
1465
old_label=old_label, new_label=new_label)
1466
1467
1468
class cmd_deleted(Command):
1469
"""List files deleted in the working tree.
1470
"""
1471
# TODO: Show files deleted since a previous revision, or
1472
# between two revisions.
1473
# TODO: Much more efficient way to do this: read in new
1474
# directories with readdir, rather than stating each one. Same
1475
# level of effort but possibly much less IO. (Or possibly not,
1476
# if the directories are very large...)
1477
_see_also = ['status', 'ls']
1478
takes_options = ['show-ids']
1479
1480
@display_command
1481
def run(self, show_ids=False):
1482
tree = WorkingTree.open_containing(u'.')[0]
1483
tree.lock_read()
1484
try:
1485
old = tree.basis_tree()
1486
old.lock_read()
1487
try:
1488
for path, ie in old.inventory.iter_entries():
1489
if not tree.has_id(ie.file_id):
1490
self.outf.write(path)
1491
if show_ids:
1492
self.outf.write(' ')
1493
self.outf.write(ie.file_id)
1494
self.outf.write('\n')
1495
finally:
1496
old.unlock()
1497
finally:
1498
tree.unlock()
1499
1500
1501
class cmd_modified(Command):
1502
"""List files modified in working tree.
1503
"""
1504
1505
hidden = True
1506
_see_also = ['status', 'ls']
1507
1508
@display_command
1509
def run(self):
1510
tree = WorkingTree.open_containing(u'.')[0]
1511
td = tree.changes_from(tree.basis_tree())
1512
for path, id, kind, text_modified, meta_modified in td.modified:
1513
self.outf.write(path + '\n')
1514
1515
1516
class cmd_added(Command):
1517
"""List files added in working tree.
1518
"""
1519
1520
hidden = True
1521
_see_also = ['status', 'ls']
1522
1523
@display_command
1524
def run(self):
1525
wt = WorkingTree.open_containing(u'.')[0]
1526
wt.lock_read()
1527
try:
1528
basis = wt.basis_tree()
1529
basis.lock_read()
1530
try:
1531
basis_inv = basis.inventory
1532
inv = wt.inventory
1533
for file_id in inv:
1534
if file_id in basis_inv:
1535
continue
1536
if inv.is_root(file_id) and len(basis_inv) == 0:
1537
continue
1538
path = inv.id2path(file_id)
1539
if not os.access(osutils.abspath(path), os.F_OK):
1540
continue
1541
self.outf.write(path + '\n')
1542
finally:
1543
basis.unlock()
1544
finally:
1545
wt.unlock()
1546
1547
1548
class cmd_root(Command):
1549
"""Show the tree root directory.
1550
1551
The root is the nearest enclosing directory with a .bzr control
1552
directory."""
1553
1554
takes_args = ['filename?']
1555
@display_command
1556
def run(self, filename=None):
1557
"""Print the branch root."""
1558
tree = WorkingTree.open_containing(filename)[0]
1559
self.outf.write(tree.basedir + '\n')
1560
1561
1562
def _parse_limit(limitstring):
1563
try:
1564
return int(limitstring)
1565
except ValueError:
1566
msg = "The limit argument must be an integer."
1567
raise errors.BzrCommandError(msg)
1568
1569
1570
class cmd_log(Command):
1571
"""Show log of a branch, file, or directory.
1572
1573
By default show the log of the branch containing the working directory.
1574
1575
To request a range of logs, you can use the command -r begin..end
1576
-r revision requests a specific revision, -r ..end or -r begin.. are
1577
also valid.
1578
1579
examples:
1580
bzr log
1581
bzr log foo.c
1582
bzr log -r -10.. http://server/branch
1583
"""
1584
1585
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1586
1587
takes_args = ['location?']
1588
takes_options = [
1589
Option('forward',
1590
help='Show from oldest to newest.'),
1591
'timezone',
1592
Option('verbose',
1593
short_name='v',
1594
help='Show files changed in each revision.'),
1595
'show-ids',
1596
'revision',
1597
'log-format',
1598
Option('message',
1599
short_name='m',
1600
help='Show revisions whose message matches this '
1601
'regular expression.',
1602
type=str),
1603
Option('limit',
1604
help='Limit the output to the first N revisions.',
1605
argname='N',
1606
type=_parse_limit),
1607
]
1608
encoding_type = 'replace'
1609
1610
@display_command
1611
def run(self, location=None, timezone='original',
1612
verbose=False,
1613
show_ids=False,
1614
forward=False,
1615
revision=None,
1616
log_format=None,
1617
message=None,
1618
limit=None):
1619
from bzrlib.log import show_log
1620
assert message is None or isinstance(message, basestring), \
1621
"invalid message argument %r" % message
1622
direction = (forward and 'forward') or 'reverse'
1623
1624
# log everything
1625
file_id = None
1626
if location:
1627
# find the file id to log:
1628
1629
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
1630
location)
1631
if fp != '':
1632
if tree is None:
1633
tree = b.basis_tree()
1634
file_id = tree.path2id(fp)
1635
if file_id is None:
1636
raise errors.BzrCommandError(
1637
"Path does not have any revision history: %s" %
1638
location)
1639
else:
1640
# local dir only
1641
# FIXME ? log the current subdir only RBC 20060203
1642
if revision is not None \
1643
and len(revision) > 0 and revision[0].get_branch():
1644
location = revision[0].get_branch()
1645
else:
1646
location = '.'
1647
dir, relpath = bzrdir.BzrDir.open_containing(location)
1648
b = dir.open_branch()
1649
1650
b.lock_read()
1651
try:
1652
if revision is None:
1653
rev1 = None
1654
rev2 = None
1655
elif len(revision) == 1:
1656
rev1 = rev2 = revision[0].in_history(b)
1657
elif len(revision) == 2:
1658
if revision[1].get_branch() != revision[0].get_branch():
1659
# b is taken from revision[0].get_branch(), and
1660
# show_log will use its revision_history. Having
1661
# different branches will lead to weird behaviors.
1662
raise errors.BzrCommandError(
1663
"Log doesn't accept two revisions in different"
1664
" branches.")
1665
rev1 = revision[0].in_history(b)
1666
rev2 = revision[1].in_history(b)
1667
else:
1668
raise errors.BzrCommandError(
1669
'bzr log --revision takes one or two values.')
1670
1671
if log_format is None:
1672
log_format = log.log_formatter_registry.get_default(b)
1673
1674
lf = log_format(show_ids=show_ids, to_file=self.outf,
1675
show_timezone=timezone)
1676
1677
show_log(b,
1678
lf,
1679
file_id,
1680
verbose=verbose,
1681
direction=direction,
1682
start_revision=rev1,
1683
end_revision=rev2,
1684
search=message,
1685
limit=limit)
1686
finally:
1687
b.unlock()
1688
1689
1690
def get_log_format(long=False, short=False, line=False, default='long'):
1691
log_format = default
1692
if long:
1693
log_format = 'long'
1694
if short:
1695
log_format = 'short'
1696
if line:
1697
log_format = 'line'
1698
return log_format
1699
1700
1701
class cmd_touching_revisions(Command):
1702
"""Return revision-ids which affected a particular file.
1703
1704
A more user-friendly interface is "bzr log FILE".
1705
"""
1706
1707
hidden = True
1708
takes_args = ["filename"]
1709
1710
@display_command
1711
def run(self, filename):
1712
tree, relpath = WorkingTree.open_containing(filename)
1713
b = tree.branch
1714
file_id = tree.path2id(relpath)
1715
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1716
self.outf.write("%6d %s\n" % (revno, what))
1717
1718
1719
class cmd_ls(Command):
1720
"""List files in a tree.
1721
"""
1722
1723
_see_also = ['status', 'cat']
1724
takes_args = ['path?']
1725
# TODO: Take a revision or remote path and list that tree instead.
1726
takes_options = [
1727
'verbose',
1728
'revision',
1729
Option('non-recursive',
1730
help='Don\'t recurse into subdirectories.'),
1731
Option('from-root',
1732
help='Print paths relative to the root of the branch.'),
1733
Option('unknown', help='Print unknown files.'),
1734
Option('versioned', help='Print versioned files.'),
1735
Option('ignored', help='Print ignored files.'),
1736
Option('null',
1737
help='Write an ascii NUL (\\0) separator '
1738
'between files rather than a newline.'),
1739
'kind',
1740
'show-ids',
1741
]
1742
@display_command
1743
def run(self, revision=None, verbose=False,
1744
non_recursive=False, from_root=False,
1745
unknown=False, versioned=False, ignored=False,
1746
null=False, kind=None, show_ids=False, path=None):
1747
1748
if kind and kind not in ('file', 'directory', 'symlink'):
1749
raise errors.BzrCommandError('invalid kind specified')
1750
1751
if verbose and null:
1752
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1753
all = not (unknown or versioned or ignored)
1754
1755
selection = {'I':ignored, '?':unknown, 'V':versioned}
1756
1757
if path is None:
1758
fs_path = '.'
1759
prefix = ''
1760
else:
1761
if from_root:
1762
raise errors.BzrCommandError('cannot specify both --from-root'
1763
' and PATH')
1764
fs_path = path
1765
prefix = path
1766
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
1767
fs_path)
1768
if from_root:
1769
relpath = u''
1770
elif relpath:
1771
relpath += '/'
1772
if revision is not None:
1773
tree = branch.repository.revision_tree(
1774
revision[0].in_history(branch).rev_id)
1775
elif tree is None:
1776
tree = branch.basis_tree()
1777
1778
tree.lock_read()
1779
try:
1780
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1781
if fp.startswith(relpath):
1782
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1783
if non_recursive and '/' in fp:
1784
continue
1785
if not all and not selection[fc]:
1786
continue
1787
if kind is not None and fkind != kind:
1788
continue
1789
if verbose:
1790
kindch = entry.kind_character()
1791
outstring = '%-8s %s%s' % (fc, fp, kindch)
1792
if show_ids and fid is not None:
1793
outstring = "%-50s %s" % (outstring, fid)
1794
self.outf.write(outstring + '\n')
1795
elif null:
1796
self.outf.write(fp + '\0')
1797
if show_ids:
1798
if fid is not None:
1799
self.outf.write(fid)
1800
self.outf.write('\0')
1801
self.outf.flush()
1802
else:
1803
if fid is not None:
1804
my_id = fid
1805
else:
1806
my_id = ''
1807
if show_ids:
1808
self.outf.write('%-50s %s\n' % (fp, my_id))
1809
else:
1810
self.outf.write(fp + '\n')
1811
finally:
1812
tree.unlock()
1813
1814
1815
class cmd_unknowns(Command):
1816
"""List unknown files.
1817
"""
1818
1819
hidden = True
1820
_see_also = ['ls']
1821
1822
@display_command
1823
def run(self):
1824
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1825
self.outf.write(osutils.quotefn(f) + '\n')
1826
1827
1828
class cmd_ignore(Command):
1829
"""Ignore specified files or patterns.
1830
1831
To remove patterns from the ignore list, edit the .bzrignore file.
1832
1833
Trailing slashes on patterns are ignored.
1834
If the pattern contains a slash or is a regular expression, it is compared
1835
to the whole path from the branch root. Otherwise, it is compared to only
1836
the last component of the path. To match a file only in the root
1837
directory, prepend './'.
1838
1839
Ignore patterns specifying absolute paths are not allowed.
1840
1841
Ignore patterns may include globbing wildcards such as:
1842
? - Matches any single character except '/'
1843
* - Matches 0 or more characters except '/'
1844
/**/ - Matches 0 or more directories in a path
1845
[a-z] - Matches a single character from within a group of characters
1846
1847
Ignore patterns may also be Python regular expressions.
1848
Regular expression ignore patterns are identified by a 'RE:' prefix
1849
followed by the regular expression. Regular expression ignore patterns
1850
may not include named or numbered groups.
1851
1852
Note: ignore patterns containing shell wildcards must be quoted from
1853
the shell on Unix.
1854
1855
examples:
1856
bzr ignore ./Makefile
1857
bzr ignore '*.class'
1858
bzr ignore 'lib/**/*.o'
1859
bzr ignore 'RE:lib/.*\.o'
1860
"""
1861
1862
_see_also = ['status', 'ignored']
1863
takes_args = ['name_pattern*']
1864
takes_options = [
1865
Option('old-default-rules',
1866
help='Write out the ignore rules bzr < 0.9 always used.')
1867
]
1868
1869
def run(self, name_pattern_list=None, old_default_rules=None):
1870
from bzrlib.atomicfile import AtomicFile
1871
if old_default_rules is not None:
1872
# dump the rules and exit
1873
for pattern in ignores.OLD_DEFAULTS:
1874
print pattern
1875
return
1876
if not name_pattern_list:
1877
raise errors.BzrCommandError("ignore requires at least one "
1878
"NAME_PATTERN or --old-default-rules")
1879
name_pattern_list = [globbing.normalize_pattern(p)
1880
for p in name_pattern_list]
1881
for name_pattern in name_pattern_list:
1882
if (name_pattern[0] == '/' or
1883
(len(name_pattern) > 1 and name_pattern[1] == ':')):
1884
raise errors.BzrCommandError(
1885
"NAME_PATTERN should not be an absolute path")
1886
tree, relpath = WorkingTree.open_containing(u'.')
1887
ifn = tree.abspath('.bzrignore')
1888
if os.path.exists(ifn):
1889
f = open(ifn, 'rt')
1890
try:
1891
igns = f.read().decode('utf-8')
1892
finally:
1893
f.close()
1894
else:
1895
igns = ''
1896
1897
# TODO: If the file already uses crlf-style termination, maybe
1898
# we should use that for the newly added lines?
1899
1900
if igns and igns[-1] != '\n':
1901
igns += '\n'
1902
for name_pattern in name_pattern_list:
1903
igns += name_pattern + '\n'
1904
1905
f = AtomicFile(ifn, 'wb')
1906
try:
1907
f.write(igns.encode('utf-8'))
1908
f.commit()
1909
finally:
1910
f.close()
1911
1912
if not tree.path2id('.bzrignore'):
1913
tree.add(['.bzrignore'])
1914
1915
1916
class cmd_ignored(Command):
1917
"""List ignored files and the patterns that matched them.
1918
"""
1919
1920
_see_also = ['ignore']
1921
@display_command
1922
def run(self):
1923
tree = WorkingTree.open_containing(u'.')[0]
1924
tree.lock_read()
1925
try:
1926
for path, file_class, kind, file_id, entry in tree.list_files():
1927
if file_class != 'I':
1928
continue
1929
## XXX: Slightly inefficient since this was already calculated
1930
pat = tree.is_ignored(path)
1931
print '%-50s %s' % (path, pat)
1932
finally:
1933
tree.unlock()
1934
1935
1936
class cmd_lookup_revision(Command):
1937
"""Lookup the revision-id from a revision-number
1938
1939
example:
1940
bzr lookup-revision 33
1941
"""
1942
hidden = True
1943
takes_args = ['revno']
1944
1945
@display_command
1946
def run(self, revno):
1947
try:
1948
revno = int(revno)
1949
except ValueError:
1950
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
1951
1952
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1953
1954
1955
class cmd_export(Command):
1956
"""Export current or past revision to a destination directory or archive.
1957
1958
If no revision is specified this exports the last committed revision.
1959
1960
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1961
given, try to find the format with the extension. If no extension
1962
is found exports to a directory (equivalent to --format=dir).
1963
1964
If root is supplied, it will be used as the root directory inside
1965
container formats (tar, zip, etc). If it is not supplied it will default
1966
to the exported filename. The root option has no effect for 'dir' format.
1967
1968
If branch is omitted then the branch containing the current working
1969
directory will be used.
1970
1971
Note: Export of tree with non-ASCII filenames to zip is not supported.
1972
1973
Supported formats Autodetected by extension
1974
----------------- -------------------------
1975
dir -
1976
tar .tar
1977
tbz2 .tar.bz2, .tbz2
1978
tgz .tar.gz, .tgz
1979
zip .zip
1980
"""
1981
takes_args = ['dest', 'branch?']
1982
takes_options = ['revision', 'format', 'root']
1983
def run(self, dest, branch=None, revision=None, format=None, root=None):
1984
from bzrlib.export import export
1985
1986
if branch is None:
1987
tree = WorkingTree.open_containing(u'.')[0]
1988
b = tree.branch
1989
else:
1990
b = Branch.open(branch)
1991
1992
if revision is None:
1993
# should be tree.last_revision FIXME
1994
rev_id = b.last_revision()
1995
else:
1996
if len(revision) != 1:
1997
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
1998
rev_id = revision[0].in_history(b).rev_id
1999
t = b.repository.revision_tree(rev_id)
2000
try:
2001
export(t, dest, format, root)
2002
except errors.NoSuchExportFormat, e:
2003
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2004
2005
2006
class cmd_cat(Command):
2007
"""Write the contents of a file as of a given revision to standard output.
2008
2009
If no revision is nominated, the last revision is used.
2010
2011
Note: Take care to redirect standard output when using this command on a
2012
binary file.
2013
"""
2014
2015
_see_also = ['ls']
2016
takes_options = ['revision', 'name-from-revision']
2017
takes_args = ['filename']
2018
encoding_type = 'exact'
2019
2020
@display_command
2021
def run(self, filename, revision=None, name_from_revision=False):
2022
if revision is not None and len(revision) != 1:
2023
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2024
" one number")
2025
2026
tree = None
2027
try:
2028
tree, b, relpath = \
2029
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2030
except errors.NotBranchError:
2031
pass
2032
2033
if revision is not None and revision[0].get_branch() is not None:
2034
b = Branch.open(revision[0].get_branch())
2035
if tree is None:
2036
tree = b.basis_tree()
2037
if revision is None:
2038
revision_id = b.last_revision()
2039
else:
2040
revision_id = revision[0].in_history(b).rev_id
2041
2042
cur_file_id = tree.path2id(relpath)
2043
rev_tree = b.repository.revision_tree(revision_id)
2044
old_file_id = rev_tree.path2id(relpath)
2045
2046
if name_from_revision:
2047
if old_file_id is None:
2048
raise errors.BzrCommandError("%r is not present in revision %s"
2049
% (filename, revision_id))
2050
else:
2051
rev_tree.print_file(old_file_id)
2052
elif cur_file_id is not None:
2053
rev_tree.print_file(cur_file_id)
2054
elif old_file_id is not None:
2055
rev_tree.print_file(old_file_id)
2056
else:
2057
raise errors.BzrCommandError("%r is not present in revision %s" %
2058
(filename, revision_id))
2059
2060
2061
class cmd_local_time_offset(Command):
2062
"""Show the offset in seconds from GMT to local time."""
2063
hidden = True
2064
@display_command
2065
def run(self):
2066
print osutils.local_time_offset()
2067
2068
2069
2070
class cmd_commit(Command):
2071
"""Commit changes into a new revision.
2072
2073
If no arguments are given, the entire tree is committed.
2074
2075
If selected files are specified, only changes to those files are
2076
committed. If a directory is specified then the directory and everything
2077
within it is committed.
2078
2079
A selected-file commit may fail in some cases where the committed
2080
tree would be invalid. Consider::
2081
2082
bzr init foo
2083
mkdir foo/bar
2084
bzr add foo/bar
2085
bzr commit foo -m "committing foo"
2086
bzr mv foo/bar foo/baz
2087
mkdir foo/bar
2088
bzr add foo/bar
2089
bzr commit foo/bar -m "committing bar but not baz"
2090
2091
In the example above, the last commit will fail by design. This gives
2092
the user the opportunity to decide whether they want to commit the
2093
rename at the same time, separately first, or not at all. (As a general
2094
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2095
2096
Note: A selected-file commit after a merge is not yet supported.
2097
"""
2098
# TODO: Run hooks on tree to-be-committed, and after commit.
2099
2100
# TODO: Strict commit that fails if there are deleted files.
2101
# (what does "deleted files" mean ??)
2102
2103
# TODO: Give better message for -s, --summary, used by tla people
2104
2105
# XXX: verbose currently does nothing
2106
2107
_see_also = ['bugs', 'uncommit']
2108
takes_args = ['selected*']
2109
takes_options = [
2110
'message',
2111
'verbose',
2112
Option('unchanged',
2113
help='Commit even if nothing has changed.'),
2114
Option('file', type=str,
2115
short_name='F',
2116
argname='msgfile',
2117
help='Take commit message from this file.'),
2118
Option('strict',
2119
help="Refuse to commit if there are unknown "
2120
"files in the working tree."),
2121
ListOption('fixes', type=str,
2122
help="Mark a bug as being fixed by this revision."),
2123
Option('local',
2124
help="Perform a local commit in a bound "
2125
"branch. Local commits are not pushed to "
2126
"the master branch until a normal commit "
2127
"is performed."
2128
),
2129
]
2130
aliases = ['ci', 'checkin']
2131
2132
def _get_bug_fix_properties(self, fixes, branch):
2133
properties = []
2134
# Configure the properties for bug fixing attributes.
2135
for fixed_bug in fixes:
2136
tokens = fixed_bug.split(':')
2137
if len(tokens) != 2:
2138
raise errors.BzrCommandError(
2139
"Invalid bug %s. Must be in the form of 'tag:id'. "
2140
"Commit refused." % fixed_bug)
2141
tag, bug_id = tokens
2142
try:
2143
bug_url = bugtracker.get_bug_url(tag, branch, bug_id)
2144
except errors.UnknownBugTrackerAbbreviation:
2145
raise errors.BzrCommandError(
2146
'Unrecognized bug %s. Commit refused.' % fixed_bug)
2147
except errors.MalformedBugIdentifier:
2148
raise errors.BzrCommandError(
2149
"Invalid bug identifier for %s. Commit refused."
2150
% fixed_bug)
2151
properties.append('%s fixed' % bug_url)
2152
return '\n'.join(properties)
2153
2154
def run(self, message=None, file=None, verbose=True, selected_list=None,
2155
unchanged=False, strict=False, local=False, fixes=None):
2156
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
2157
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
2158
StrictCommitFailed)
2159
from bzrlib.msgeditor import edit_commit_message, \
2160
make_commit_message_template
2161
2162
# TODO: Need a blackbox test for invoking the external editor; may be
2163
# slightly problematic to run this cross-platform.
2164
2165
# TODO: do more checks that the commit will succeed before
2166
# spending the user's valuable time typing a commit message.
2167
2168
properties = {}
2169
2170
tree, selected_list = tree_files(selected_list)
2171
if selected_list == ['']:
2172
# workaround - commit of root of tree should be exactly the same
2173
# as just default commit in that tree, and succeed even though
2174
# selected-file merge commit is not done yet
2175
selected_list = []
2176
2177
bug_property = self._get_bug_fix_properties(fixes, tree.branch)
2178
if bug_property:
2179
properties['bugs'] = bug_property
2180
2181
if local and not tree.branch.get_bound_location():
2182
raise errors.LocalRequiresBoundBranch()
2183
2184
def get_message(commit_obj):
2185
"""Callback to get commit message"""
2186
my_message = message
2187
if my_message is None and not file:
2188
template = make_commit_message_template(tree, selected_list)
2189
my_message = edit_commit_message(template)
2190
if my_message is None:
2191
raise errors.BzrCommandError("please specify a commit"
2192
" message with either --message or --file")
2193
elif my_message and file:
2194
raise errors.BzrCommandError(
2195
"please specify either --message or --file")
2196
if file:
2197
my_message = codecs.open(file, 'rt',
2198
bzrlib.user_encoding).read()
2199
if my_message == "":
2200
raise errors.BzrCommandError("empty commit message specified")
2201
return my_message
2202
2203
if verbose:
2204
reporter = ReportCommitToLog()
2205
else:
2206
reporter = NullCommitReporter()
2207
2208
try:
2209
tree.commit(message_callback=get_message,
2210
specific_files=selected_list,
2211
allow_pointless=unchanged, strict=strict, local=local,
2212
reporter=reporter, revprops=properties)
2213
except PointlessCommit:
2214
# FIXME: This should really happen before the file is read in;
2215
# perhaps prepare the commit; get the message; then actually commit
2216
raise errors.BzrCommandError("no changes to commit."
2217
" use --unchanged to commit anyhow")
2218
except ConflictsInTree:
2219
raise errors.BzrCommandError('Conflicts detected in working '
2220
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
2221
' resolve.')
2222
except StrictCommitFailed:
2223
raise errors.BzrCommandError("Commit refused because there are"
2224
" unknown files in the working tree.")
2225
except errors.BoundBranchOutOfDate, e:
2226
raise errors.BzrCommandError(str(e) + "\n"
2227
'To commit to master branch, run update and then commit.\n'
2228
'You can also pass --local to commit to continue working '
2229
'disconnected.')
2230
2231
2232
class cmd_check(Command):
2233
"""Validate consistency of branch history.
2234
2235
This command checks various invariants about the branch storage to
2236
detect data corruption or bzr bugs.
2237
"""
2238
2239
_see_also = ['reconcile']
2240
takes_args = ['branch?']
2241
takes_options = ['verbose']
2242
2243
def run(self, branch=None, verbose=False):
2244
from bzrlib.check import check
2245
if branch is None:
2246
tree = WorkingTree.open_containing()[0]
2247
branch = tree.branch
2248
else:
2249
branch = Branch.open(branch)
2250
check(branch, verbose)
2251
2252
2253
class cmd_upgrade(Command):
2254
"""Upgrade branch storage to current format.
2255
2256
The check command or bzr developers may sometimes advise you to run
2257
this command. When the default format has changed you may also be warned
2258
during other operations to upgrade.
2259
"""
2260
2261
_see_also = ['check']
2262
takes_args = ['url?']
2263
takes_options = [
2264
RegistryOption('format',
2265
help='Upgrade to a specific format. See "bzr help'
2266
' formats" for details.',
2267
registry=bzrdir.format_registry,
2268
converter=bzrdir.format_registry.make_bzrdir,
2269
value_switches=True, title='Branch format'),
2270
]
2271
2272
def run(self, url='.', format=None):
2273
from bzrlib.upgrade import upgrade
2274
if format is None:
2275
format = bzrdir.format_registry.make_bzrdir('default')
2276
upgrade(url, format)
2277
2278
2279
class cmd_whoami(Command):
2280
"""Show or set bzr user id.
2281
2282
examples:
2283
bzr whoami --email
2284
bzr whoami 'Frank Chu <fchu@example.com>'
2285
"""
2286
takes_options = [ Option('email',
2287
help='Display email address only.'),
2288
Option('branch',
2289
help='Set identity for the current branch instead of '
2290
'globally.'),
2291
]
2292
takes_args = ['name?']
2293
encoding_type = 'replace'
2294
2295
@display_command
2296
def run(self, email=False, branch=False, name=None):
2297
if name is None:
2298
# use branch if we're inside one; otherwise global config
2299
try:
2300
c = Branch.open_containing('.')[0].get_config()
2301
except errors.NotBranchError:
2302
c = config.GlobalConfig()
2303
if email:
2304
self.outf.write(c.user_email() + '\n')
2305
else:
2306
self.outf.write(c.username() + '\n')
2307
return
2308
2309
# display a warning if an email address isn't included in the given name.
2310
try:
2311
config.extract_email_address(name)
2312
except errors.NoEmailInUsername, e:
2313
warning('"%s" does not seem to contain an email address. '
2314
'This is allowed, but not recommended.', name)
2315
2316
# use global config unless --branch given
2317
if branch:
2318
c = Branch.open_containing('.')[0].get_config()
2319
else:
2320
c = config.GlobalConfig()
2321
c.set_user_option('email', name)
2322
2323
2324
class cmd_nick(Command):
2325
"""Print or set the branch nickname.
2326
2327
If unset, the tree root directory name is used as the nickname
2328
To print the current nickname, execute with no argument.
2329
"""
2330
2331
_see_also = ['info']
2332
takes_args = ['nickname?']
2333
def run(self, nickname=None):
2334
branch = Branch.open_containing(u'.')[0]
2335
if nickname is None:
2336
self.printme(branch)
2337
else:
2338
branch.nick = nickname
2339
2340
@display_command
2341
def printme(self, branch):
2342
print branch.nick
2343
2344
2345
class cmd_selftest(Command):
2346
"""Run internal test suite.
2347
2348
If arguments are given, they are regular expressions that say which tests
2349
should run. Tests matching any expression are run, and other tests are
2350
not run.
2351
2352
Alternatively if --first is given, matching tests are run first and then
2353
all other tests are run. This is useful if you have been working in a
2354
particular area, but want to make sure nothing else was broken.
2355
2356
If --exclude is given, tests that match that regular expression are
2357
excluded, regardless of whether they match --first or not.
2358
2359
To help catch accidential dependencies between tests, the --randomize
2360
option is useful. In most cases, the argument used is the word 'now'.
2361
Note that the seed used for the random number generator is displayed
2362
when this option is used. The seed can be explicitly passed as the
2363
argument to this option if required. This enables reproduction of the
2364
actual ordering used if and when an order sensitive problem is encountered.
2365
2366
If --list-only is given, the tests that would be run are listed. This is
2367
useful when combined with --first, --exclude and/or --randomize to
2368
understand their impact. The test harness reports "Listed nn tests in ..."
2369
instead of "Ran nn tests in ..." when list mode is enabled.
2370
2371
If the global option '--no-plugins' is given, plugins are not loaded
2372
before running the selftests. This has two effects: features provided or
2373
modified by plugins will not be tested, and tests provided by plugins will
2374
not be run.
2375
2376
examples::
2377
bzr selftest ignore
2378
run only tests relating to 'ignore'
2379
bzr --no-plugins selftest -v
2380
disable plugins and list tests as they're run
2381
2382
For each test, that needs actual disk access, bzr create their own
2383
subdirectory in the temporary testing directory (testXXXX.tmp).
2384
By default the name of such subdirectory is based on the name of the test.
2385
If option '--numbered-dirs' is given, bzr will use sequent numbers
2386
of running tests to create such subdirectories. This is default behavior
2387
on Windows because of path length limitation.
2388
"""
2389
# NB: this is used from the class without creating an instance, which is
2390
# why it does not have a self parameter.
2391
def get_transport_type(typestring):
2392
"""Parse and return a transport specifier."""
2393
if typestring == "sftp":
2394
from bzrlib.transport.sftp import SFTPAbsoluteServer
2395
return SFTPAbsoluteServer
2396
if typestring == "memory":
2397
from bzrlib.transport.memory import MemoryServer
2398
return MemoryServer
2399
if typestring == "fakenfs":
2400
from bzrlib.transport.fakenfs import FakeNFSServer
2401
return FakeNFSServer
2402
msg = "No known transport type %s. Supported types are: sftp\n" %\
2403
(typestring)
2404
raise errors.BzrCommandError(msg)
2405
2406
hidden = True
2407
takes_args = ['testspecs*']
2408
takes_options = ['verbose',
2409
Option('one',
2410
help='Stop when one test fails.',
2411
short_name='1',
2412
),
2413
Option('keep-output',
2414
help='Keep output directories when tests fail.'),
2415
Option('transport',
2416
help='Use a different transport by default '
2417
'throughout the test suite.',
2418
type=get_transport_type),
2419
Option('benchmark',
2420
help='Run the benchmarks rather than selftests.'),
2421
Option('lsprof-timed',
2422
help='Generate lsprof output for benchmarked'
2423
' sections of code.'),
2424
Option('cache-dir', type=str,
2425
help='Cache intermediate benchmark output in this '
2426
'directory.'),
2427
Option('clean-output',
2428
help='Clean temporary tests directories'
2429
' without running tests.'),
2430
Option('first',
2431
help='Run all tests, but run specified tests first.',
2432
short_name='f',
2433
),
2434
Option('numbered-dirs',
2435
help='Use numbered dirs for TestCaseInTempDir.'),
2436
Option('list-only',
2437
help='List the tests instead of running them.'),
2438
Option('randomize', type=str, argname="SEED",
2439
help='Randomize the order of tests using the given'
2440
' seed or "now" for the current time.'),
2441
Option('exclude', type=str, argname="PATTERN",
2442
short_name='x',
2443
help='Exclude tests that match this regular'
2444
' expression.'),
2445
]
2446
encoding_type = 'replace'
2447
2448
def run(self, testspecs_list=None, verbose=None, one=False,
2449
keep_output=False, transport=None, benchmark=None,
2450
lsprof_timed=None, cache_dir=None, clean_output=False,
2451
first=False, numbered_dirs=None, list_only=False,
2452
randomize=None, exclude=None):
2453
import bzrlib.ui
2454
from bzrlib.tests import selftest
2455
import bzrlib.benchmarks as benchmarks
2456
from bzrlib.benchmarks import tree_creator
2457
2458
if clean_output:
2459
from bzrlib.tests import clean_selftest_output
2460
clean_selftest_output()
2461
return 0
2462
if keep_output:
2463
warning("notice: selftest --keep-output "
2464
"is no longer supported; "
2465
"test output is always removed")
2466
2467
if numbered_dirs is None and sys.platform == 'win32':
2468
numbered_dirs = True
2469
2470
if cache_dir is not None:
2471
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2472
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
2473
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2474
print
2475
if testspecs_list is not None:
2476
pattern = '|'.join(testspecs_list)
2477
else:
2478
pattern = ".*"
2479
if benchmark:
2480
test_suite_factory = benchmarks.test_suite
2481
if verbose is None:
2482
verbose = True
2483
# TODO: should possibly lock the history file...
2484
benchfile = open(".perf_history", "at", buffering=1)
2485
else:
2486
test_suite_factory = None
2487
if verbose is None:
2488
verbose = False
2489
benchfile = None
2490
try:
2491
result = selftest(verbose=verbose,
2492
pattern=pattern,
2493
stop_on_failure=one,
2494
transport=transport,
2495
test_suite_factory=test_suite_factory,
2496
lsprof_timed=lsprof_timed,
2497
bench_history=benchfile,
2498
matching_tests_first=first,
2499
numbered_dirs=numbered_dirs,
2500
list_only=list_only,
2501
random_seed=randomize,
2502
exclude_pattern=exclude
2503
)
2504
finally:
2505
if benchfile is not None:
2506
benchfile.close()
2507
if result:
2508
info('tests passed')
2509
else:
2510
info('tests failed')
2511
return int(not result)
2512
2513
2514
class cmd_version(Command):
2515
"""Show version of bzr."""
2516
2517
@display_command
2518
def run(self):
2519
from bzrlib.version import show_version
2520
show_version()
2521
2522
2523
class cmd_rocks(Command):
2524
"""Statement of optimism."""
2525
2526
hidden = True
2527
2528
@display_command
2529
def run(self):
2530
print "It sure does!"
2531
2532
2533
class cmd_find_merge_base(Command):
2534
"""Find and print a base revision for merging two branches."""
2535
# TODO: Options to specify revisions on either side, as if
2536
# merging only part of the history.
2537
takes_args = ['branch', 'other']
2538
hidden = True
2539
2540
@display_command
2541
def run(self, branch, other):
2542
from bzrlib.revision import ensure_null, MultipleRevisionSources
2543
2544
branch1 = Branch.open_containing(branch)[0]
2545
branch2 = Branch.open_containing(other)[0]
2546
2547
last1 = ensure_null(branch1.last_revision())
2548
last2 = ensure_null(branch2.last_revision())
2549
2550
graph = branch1.repository.get_graph(branch2.repository)
2551
base_rev_id = graph.find_unique_lca(last1, last2)
2552
2553
print 'merge base is revision %s' % base_rev_id
2554
2555
2556
class cmd_merge(Command):
2557
"""Perform a three-way merge.
2558
2559
The branch is the branch you will merge from. By default, it will merge
2560
the latest revision. If you specify a revision, that revision will be
2561
merged. If you specify two revisions, the first will be used as a BASE,
2562
and the second one as OTHER. Revision numbers are always relative to the
2563
specified branch.
2564
2565
By default, bzr will try to merge in all new work from the other
2566
branch, automatically determining an appropriate base. If this
2567
fails, you may need to give an explicit base.
2568
2569
Merge will do its best to combine the changes in two branches, but there
2570
are some kinds of problems only a human can fix. When it encounters those,
2571
it will mark a conflict. A conflict means that you need to fix something,
2572
before you should commit.
2573
2574
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2575
2576
If there is no default branch set, the first merge will set it. After
2577
that, you can omit the branch to use the default. To change the
2578
default, use --remember. The value will only be saved if the remote
2579
location can be accessed.
2580
2581
The results of the merge are placed into the destination working
2582
directory, where they can be reviewed (with bzr diff), tested, and then
2583
committed to record the result of the merge.
2584
2585
Examples:
2586
2587
To merge the latest revision from bzr.dev:
2588
bzr merge ../bzr.dev
2589
2590
To merge changes up to and including revision 82 from bzr.dev:
2591
bzr merge -r 82 ../bzr.dev
2592
2593
To merge the changes introduced by 82, without previous changes:
2594
bzr merge -r 81..82 ../bzr.dev
2595
2596
merge refuses to run if there are any uncommitted changes, unless
2597
--force is given.
2598
"""
2599
2600
_see_also = ['update', 'remerge', 'status-flags']
2601
takes_args = ['branch?']
2602
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2603
Option('show-base', help="Show base revision text in "
2604
"conflicts."),
2605
Option('uncommitted', help='Apply uncommitted changes'
2606
' from a working copy, instead of branch changes.'),
2607
Option('pull', help='If the destination is already'
2608
' completely merged into the source, pull from the'
2609
' source rather than merging. When this happens,'
2610
' you do not need to commit the result.'),
2611
Option('directory',
2612
help='Branch to merge into, '
2613
'rather than the one containing the working directory.',
2614
short_name='d',
2615
type=unicode,
2616
),
2617
]
2618
2619
def run(self, branch=None, revision=None, force=False, merge_type=None,
2620
show_base=False, reprocess=False, remember=False,
2621
uncommitted=False, pull=False,
2622
directory=None,
2623
):
2624
from bzrlib.tag import _merge_tags_if_possible
2625
other_revision_id = None
2626
if merge_type is None:
2627
merge_type = _mod_merge.Merge3Merger
2628
2629
if directory is None: directory = u'.'
2630
# XXX: jam 20070225 WorkingTree should be locked before you extract its
2631
# inventory. Because merge is a mutating operation, it really
2632
# should be a lock_write() for the whole cmd_merge operation.
2633
# However, cmd_merge open's its own tree in _merge_helper, which
2634
# means if we lock here, the later lock_write() will always block.
2635
# Either the merge helper code should be updated to take a tree,
2636
# (What about tree.merge_from_branch?)
2637
tree = WorkingTree.open_containing(directory)[0]
2638
change_reporter = delta._ChangeReporter(
2639
unversioned_filter=tree.is_ignored)
2640
2641
if branch is not None:
2642
try:
2643
mergeable = bundle.read_mergeable_from_url(
2644
branch)
2645
except errors.NotABundle:
2646
pass # Continue on considering this url a Branch
2647
else:
2648
if revision is not None:
2649
raise errors.BzrCommandError(
2650
'Cannot use -r with merge directives or bundles')
2651
other_revision_id = mergeable.install_revisions(
2652
tree.branch.repository)
2653
revision = [RevisionSpec.from_string(
2654
'revid:' + other_revision_id)]
2655
2656
if revision is None \
2657
or len(revision) < 1 or revision[0].needs_branch():
2658
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2659
2660
if revision is None or len(revision) < 1:
2661
if uncommitted:
2662
base = [branch, -1]
2663
other = [branch, None]
2664
else:
2665
base = [None, None]
2666
other = [branch, -1]
2667
other_branch, path = Branch.open_containing(branch)
2668
else:
2669
if uncommitted:
2670
raise errors.BzrCommandError('Cannot use --uncommitted and'
2671
' --revision at the same time.')
2672
branch = revision[0].get_branch() or branch
2673
if len(revision) == 1:
2674
base = [None, None]
2675
if other_revision_id is not None:
2676
other_branch = None
2677
path = ""
2678
other = None
2679
else:
2680
other_branch, path = Branch.open_containing(branch)
2681
revno = revision[0].in_history(other_branch).revno
2682
other = [branch, revno]
2683
else:
2684
assert len(revision) == 2
2685
if None in revision:
2686
raise errors.BzrCommandError(
2687
"Merge doesn't permit empty revision specifier.")
2688
base_branch, path = Branch.open_containing(branch)
2689
branch1 = revision[1].get_branch() or branch
2690
other_branch, path1 = Branch.open_containing(branch1)
2691
if revision[0].get_branch() is not None:
2692
# then path was obtained from it, and is None.
2693
path = path1
2694
2695
base = [branch, revision[0].in_history(base_branch).revno]
2696
other = [branch1, revision[1].in_history(other_branch).revno]
2697
2698
if ((tree.branch.get_parent() is None or remember) and
2699
other_branch is not None):
2700
tree.branch.set_parent(other_branch.base)
2701
2702
# pull tags now... it's a bit inconsistent to do it ahead of copying
2703
# the history but that's done inside the merge code
2704
if other_branch is not None:
2705
_merge_tags_if_possible(other_branch, tree.branch)
2706
2707
if path != "":
2708
interesting_files = [path]
2709
else:
2710
interesting_files = None
2711
pb = ui.ui_factory.nested_progress_bar()
2712
try:
2713
try:
2714
conflict_count = _merge_helper(
2715
other, base, other_rev_id=other_revision_id,
2716
check_clean=(not force),
2717
merge_type=merge_type,
2718
reprocess=reprocess,
2719
show_base=show_base,
2720
pull=pull,
2721
this_dir=directory,
2722
pb=pb, file_list=interesting_files,
2723
change_reporter=change_reporter)
2724
finally:
2725
pb.finished()
2726
if conflict_count != 0:
2727
return 1
2728
else:
2729
return 0
2730
except errors.AmbiguousBase, e:
2731
m = ("sorry, bzr can't determine the right merge base yet\n"
2732
"candidates are:\n "
2733
+ "\n ".join(e.bases)
2734
+ "\n"
2735
"please specify an explicit base with -r,\n"
2736
"and (if you want) report this to the bzr developers\n")
2737
log_error(m)
2738
2739
# TODO: move up to common parent; this isn't merge-specific anymore.
2740
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2741
"""Use tree.branch's parent if none was supplied.
2742
2743
Report if the remembered location was used.
2744
"""
2745
if supplied_location is not None:
2746
return supplied_location
2747
stored_location = tree.branch.get_parent()
2748
mutter("%s", stored_location)
2749
if stored_location is None:
2750
raise errors.BzrCommandError("No location specified or remembered")
2751
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2752
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2753
return stored_location
2754
2755
2756
class cmd_remerge(Command):
2757
"""Redo a merge.
2758
2759
Use this if you want to try a different merge technique while resolving
2760
conflicts. Some merge techniques are better than others, and remerge
2761
lets you try different ones on different files.
2762
2763
The options for remerge have the same meaning and defaults as the ones for
2764
merge. The difference is that remerge can (only) be run when there is a
2765
pending merge, and it lets you specify particular files.
2766
2767
Examples:
2768
2769
$ bzr remerge --show-base
2770
Re-do the merge of all conflicted files, and show the base text in
2771
conflict regions, in addition to the usual THIS and OTHER texts.
2772
2773
$ bzr remerge --merge-type weave --reprocess foobar
2774
Re-do the merge of "foobar", using the weave merge algorithm, with
2775
additional processing to reduce the size of conflict regions.
2776
"""
2777
takes_args = ['file*']
2778
takes_options = [
2779
'merge-type',
2780
'reprocess',
2781
Option('show-base',
2782
help="Show base revision text in conflicts."),
2783
]
2784
2785
def run(self, file_list=None, merge_type=None, show_base=False,
2786
reprocess=False):
2787
if merge_type is None:
2788
merge_type = _mod_merge.Merge3Merger
2789
tree, file_list = tree_files(file_list)
2790
tree.lock_write()
2791
try:
2792
parents = tree.get_parent_ids()
2793
if len(parents) != 2:
2794
raise errors.BzrCommandError("Sorry, remerge only works after normal"
2795
" merges. Not cherrypicking or"
2796
" multi-merges.")
2797
repository = tree.branch.repository
2798
graph = repository.get_graph()
2799
base_revision = graph.find_unique_lca(parents[0], parents[1])
2800
base_tree = repository.revision_tree(base_revision)
2801
other_tree = repository.revision_tree(parents[1])
2802
interesting_ids = None
2803
new_conflicts = []
2804
conflicts = tree.conflicts()
2805
if file_list is not None:
2806
interesting_ids = set()
2807
for filename in file_list:
2808
file_id = tree.path2id(filename)
2809
if file_id is None:
2810
raise errors.NotVersionedError(filename)
2811
interesting_ids.add(file_id)
2812
if tree.kind(file_id) != "directory":
2813
continue
2814
2815
for name, ie in tree.inventory.iter_entries(file_id):
2816
interesting_ids.add(ie.file_id)
2817
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2818
else:
2819
# Remerge only supports resolving contents conflicts
2820
allowed_conflicts = ('text conflict', 'contents conflict')
2821
restore_files = [c.path for c in conflicts
2822
if c.typestring in allowed_conflicts]
2823
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2824
tree.set_conflicts(ConflictList(new_conflicts))
2825
if file_list is not None:
2826
restore_files = file_list
2827
for filename in restore_files:
2828
try:
2829
restore(tree.abspath(filename))
2830
except errors.NotConflicted:
2831
pass
2832
conflicts = _mod_merge.merge_inner(
2833
tree.branch, other_tree, base_tree,
2834
this_tree=tree,
2835
interesting_ids=interesting_ids,
2836
other_rev_id=parents[1],
2837
merge_type=merge_type,
2838
show_base=show_base,
2839
reprocess=reprocess)
2840
finally:
2841
tree.unlock()
2842
if conflicts > 0:
2843
return 1
2844
else:
2845
return 0
2846
2847
2848
class cmd_revert(Command):
2849
"""Revert files to a previous revision.
2850
2851
Giving a list of files will revert only those files. Otherwise, all files
2852
will be reverted. If the revision is not specified with '--revision', the
2853
last committed revision is used.
2854
2855
To remove only some changes, without reverting to a prior version, use
2856
merge instead. For example, "merge . --r-2..-3" will remove the changes
2857
introduced by -2, without affecting the changes introduced by -1. Or
2858
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2859
2860
By default, any files that have been manually changed will be backed up
2861
first. (Files changed only by merge are not backed up.) Backup files have
2862
'.~#~' appended to their name, where # is a number.
2863
2864
When you provide files, you can use their current pathname or the pathname
2865
from the target revision. So you can use revert to "undelete" a file by
2866
name. If you name a directory, all the contents of that directory will be
2867
reverted.
2868
"""
2869
2870
_see_also = ['cat', 'export']
2871
takes_options = ['revision', 'no-backup']
2872
takes_args = ['file*']
2873
2874
def run(self, revision=None, no_backup=False, file_list=None):
2875
if file_list is not None:
2876
if len(file_list) == 0:
2877
raise errors.BzrCommandError("No files specified")
2878
else:
2879
file_list = []
2880
2881
tree, file_list = tree_files(file_list)
2882
if revision is None:
2883
# FIXME should be tree.last_revision
2884
rev_id = tree.last_revision()
2885
elif len(revision) != 1:
2886
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
2887
else:
2888
rev_id = revision[0].in_history(tree.branch).rev_id
2889
pb = ui.ui_factory.nested_progress_bar()
2890
try:
2891
tree.revert(file_list,
2892
tree.branch.repository.revision_tree(rev_id),
2893
not no_backup, pb, report_changes=True)
2894
finally:
2895
pb.finished()
2896
2897
2898
class cmd_assert_fail(Command):
2899
"""Test reporting of assertion failures"""
2900
# intended just for use in testing
2901
2902
hidden = True
2903
2904
def run(self):
2905
raise AssertionError("always fails")
2906
2907
2908
class cmd_help(Command):
2909
"""Show help on a command or other topic.
2910
"""
2911
2912
_see_also = ['topics']
2913
takes_options = [
2914
Option('long', 'Show help on all commands.'),
2915
]
2916
takes_args = ['topic?']
2917
aliases = ['?', '--help', '-?', '-h']
2918
2919
@display_command
2920
def run(self, topic=None, long=False):
2921
import bzrlib.help
2922
if topic is None and long:
2923
topic = "commands"
2924
bzrlib.help.help(topic)
2925
2926
2927
class cmd_shell_complete(Command):
2928
"""Show appropriate completions for context.
2929
2930
For a list of all available commands, say 'bzr shell-complete'.
2931
"""
2932
takes_args = ['context?']
2933
aliases = ['s-c']
2934
hidden = True
2935
2936
@display_command
2937
def run(self, context=None):
2938
import shellcomplete
2939
shellcomplete.shellcomplete(context)
2940
2941
2942
class cmd_fetch(Command):
2943
"""Copy in history from another branch but don't merge it.
2944
2945
This is an internal method used for pull and merge.
2946
"""
2947
hidden = True
2948
takes_args = ['from_branch', 'to_branch']
2949
def run(self, from_branch, to_branch):
2950
from bzrlib.fetch import Fetcher
2951
from_b = Branch.open(from_branch)
2952
to_b = Branch.open(to_branch)
2953
Fetcher(to_b, from_b)
2954
2955
2956
class cmd_missing(Command):
2957
"""Show unmerged/unpulled revisions between two branches.
2958
2959
OTHER_BRANCH may be local or remote.
2960
"""
2961
2962
_see_also = ['merge', 'pull']
2963
takes_args = ['other_branch?']
2964
takes_options = [
2965
Option('reverse', 'Reverse the order of revisions.'),
2966
Option('mine-only',
2967
'Display changes in the local branch only.'),
2968
Option('this' , 'Same as --mine-only.'),
2969
Option('theirs-only',
2970
'Display changes in the remote branch only.'),
2971
Option('other', 'Same as --theirs-only.'),
2972
'log-format',
2973
'show-ids',
2974
'verbose'
2975
]
2976
encoding_type = 'replace'
2977
2978
@display_command
2979
def run(self, other_branch=None, reverse=False, mine_only=False,
2980
theirs_only=False, log_format=None, long=False, short=False, line=False,
2981
show_ids=False, verbose=False, this=False, other=False):
2982
from bzrlib.missing import find_unmerged, iter_log_revisions
2983
from bzrlib.log import log_formatter
2984
2985
if this:
2986
mine_only = this
2987
if other:
2988
theirs_only = other
2989
2990
local_branch = Branch.open_containing(u".")[0]
2991
parent = local_branch.get_parent()
2992
if other_branch is None:
2993
other_branch = parent
2994
if other_branch is None:
2995
raise errors.BzrCommandError("No peer location known or specified.")
2996
display_url = urlutils.unescape_for_display(parent,
2997
self.outf.encoding)
2998
print "Using last location: " + display_url
2999
3000
remote_branch = Branch.open(other_branch)
3001
if remote_branch.base == local_branch.base:
3002
remote_branch = local_branch
3003
local_branch.lock_read()
3004
try:
3005
remote_branch.lock_read()
3006
try:
3007
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
3008
if (log_format is None):
3009
log_format = log.log_formatter_registry.get_default(
3010
local_branch)
3011
lf = log_format(to_file=self.outf,
3012
show_ids=show_ids,
3013
show_timezone='original')
3014
if reverse is False:
3015
local_extra.reverse()
3016
remote_extra.reverse()
3017
if local_extra and not theirs_only:
3018
print "You have %d extra revision(s):" % len(local_extra)
3019
for revision in iter_log_revisions(local_extra,
3020
local_branch.repository,
3021
verbose):
3022
lf.log_revision(revision)
3023
printed_local = True
3024
else:
3025
printed_local = False
3026
if remote_extra and not mine_only:
3027
if printed_local is True:
3028
print "\n\n"
3029
print "You are missing %d revision(s):" % len(remote_extra)
3030
for revision in iter_log_revisions(remote_extra,
3031
remote_branch.repository,
3032
verbose):
3033
lf.log_revision(revision)
3034
if not remote_extra and not local_extra:
3035
status_code = 0
3036
print "Branches are up to date."
3037
else:
3038
status_code = 1
3039
finally:
3040
remote_branch.unlock()
3041
finally:
3042
local_branch.unlock()
3043
if not status_code and parent is None and other_branch is not None:
3044
local_branch.lock_write()
3045
try:
3046
# handle race conditions - a parent might be set while we run.
3047
if local_branch.get_parent() is None:
3048
local_branch.set_parent(remote_branch.base)
3049
finally:
3050
local_branch.unlock()
3051
return status_code
3052
3053
3054
class cmd_plugins(Command):
3055
"""List plugins"""
3056
hidden = True
3057
@display_command
3058
def run(self):
3059
import bzrlib.plugin
3060
from inspect import getdoc
3061
for name, plugin in bzrlib.plugin.all_plugins().items():
3062
if getattr(plugin, '__path__', None) is not None:
3063
print plugin.__path__[0]
3064
elif getattr(plugin, '__file__', None) is not None:
3065
print plugin.__file__
3066
else:
3067
print repr(plugin)
3068
3069
d = getdoc(plugin)
3070
if d:
3071
print '\t', d.split('\n')[0]
3072
3073
3074
class cmd_testament(Command):
3075
"""Show testament (signing-form) of a revision."""
3076
takes_options = [
3077
'revision',
3078
Option('long', help='Produce long-format testament.'),
3079
Option('strict',
3080
help='Produce a strict-format testament.')]
3081
takes_args = ['branch?']
3082
@display_command
3083
def run(self, branch=u'.', revision=None, long=False, strict=False):
3084
from bzrlib.testament import Testament, StrictTestament
3085
if strict is True:
3086
testament_class = StrictTestament
3087
else:
3088
testament_class = Testament
3089
b = WorkingTree.open_containing(branch)[0].branch
3090
b.lock_read()
3091
try:
3092
if revision is None:
3093
rev_id = b.last_revision()
3094
else:
3095
rev_id = revision[0].in_history(b).rev_id
3096
t = testament_class.from_revision(b.repository, rev_id)
3097
if long:
3098
sys.stdout.writelines(t.as_text_lines())
3099
else:
3100
sys.stdout.write(t.as_short_text())
3101
finally:
3102
b.unlock()
3103
3104
3105
class cmd_annotate(Command):
3106
"""Show the origin of each line in a file.
3107
3108
This prints out the given file with an annotation on the left side
3109
indicating which revision, author and date introduced the change.
3110
3111
If the origin is the same for a run of consecutive lines, it is
3112
shown only at the top, unless the --all option is given.
3113
"""
3114
# TODO: annotate directories; showing when each file was last changed
3115
# TODO: if the working copy is modified, show annotations on that
3116
# with new uncommitted lines marked
3117
aliases = ['ann', 'blame', 'praise']
3118
takes_args = ['filename']
3119
takes_options = [Option('all', help='Show annotations on all lines.'),
3120
Option('long', help='Show commit date in annotations.'),
3121
'revision',
3122
'show-ids',
3123
]
3124
encoding_type = 'exact'
3125
3126
@display_command
3127
def run(self, filename, all=False, long=False, revision=None,
3128
show_ids=False):
3129
from bzrlib.annotate import annotate_file
3130
tree, relpath = WorkingTree.open_containing(filename)
3131
branch = tree.branch
3132
branch.lock_read()
3133
try:
3134
if revision is None:
3135
revision_id = branch.last_revision()
3136
elif len(revision) != 1:
3137
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
3138
else:
3139
revision_id = revision[0].in_history(branch).rev_id
3140
file_id = tree.path2id(relpath)
3141
if file_id is None:
3142
raise errors.NotVersionedError(filename)
3143
tree = branch.repository.revision_tree(revision_id)
3144
file_version = tree.inventory[file_id].revision
3145
annotate_file(branch, file_version, file_id, long, all, self.outf,
3146
show_ids=show_ids)
3147
finally:
3148
branch.unlock()
3149
3150
3151
class cmd_re_sign(Command):
3152
"""Create a digital signature for an existing revision."""
3153
# TODO be able to replace existing ones.
3154
3155
hidden = True # is this right ?
3156
takes_args = ['revision_id*']
3157
takes_options = ['revision']
3158
3159
def run(self, revision_id_list=None, revision=None):
3160
import bzrlib.gpg as gpg
3161
if revision_id_list is not None and revision is not None:
3162
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
3163
if revision_id_list is None and revision is None:
3164
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
3165
b = WorkingTree.open_containing(u'.')[0].branch
3166
gpg_strategy = gpg.GPGStrategy(b.get_config())
3167
if revision_id_list is not None:
3168
for revision_id in revision_id_list:
3169
b.repository.sign_revision(revision_id, gpg_strategy)
3170
elif revision is not None:
3171
if len(revision) == 1:
3172
revno, rev_id = revision[0].in_history(b)
3173
b.repository.sign_revision(rev_id, gpg_strategy)
3174
elif len(revision) == 2:
3175
# are they both on rh- if so we can walk between them
3176
# might be nice to have a range helper for arbitrary
3177
# revision paths. hmm.
3178
from_revno, from_revid = revision[0].in_history(b)
3179
to_revno, to_revid = revision[1].in_history(b)
3180
if to_revid is None:
3181
to_revno = b.revno()
3182
if from_revno is None or to_revno is None:
3183
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
3184
for revno in range(from_revno, to_revno + 1):
3185
b.repository.sign_revision(b.get_rev_id(revno),
3186
gpg_strategy)
3187
else:
3188
raise errors.BzrCommandError('Please supply either one revision, or a range.')
3189
3190
3191
class cmd_bind(Command):
3192
"""Convert the current branch into a checkout of the supplied branch.
3193
3194
Once converted into a checkout, commits must succeed on the master branch
3195
before they will be applied to the local branch.
3196
"""
3197
3198
_see_also = ['checkouts', 'unbind']
3199
takes_args = ['location?']
3200
takes_options = []
3201
3202
def run(self, location=None):
3203
b, relpath = Branch.open_containing(u'.')
3204
if location is None:
3205
try:
3206
location = b.get_old_bound_location()
3207
except errors.UpgradeRequired:
3208
raise errors.BzrCommandError('No location supplied. '
3209
'This format does not remember old locations.')
3210
else:
3211
if location is None:
3212
raise errors.BzrCommandError('No location supplied and no '
3213
'previous location known')
3214
b_other = Branch.open(location)
3215
try:
3216
b.bind(b_other)
3217
except errors.DivergedBranches:
3218
raise errors.BzrCommandError('These branches have diverged.'
3219
' Try merging, and then bind again.')
3220
3221
3222
class cmd_unbind(Command):
3223
"""Convert the current checkout into a regular branch.
3224
3225
After unbinding, the local branch is considered independent and subsequent
3226
commits will be local only.
3227
"""
3228
3229
_see_also = ['checkouts', 'bind']
3230
takes_args = []
3231
takes_options = []
3232
3233
def run(self):
3234
b, relpath = Branch.open_containing(u'.')
3235
if not b.unbind():
3236
raise errors.BzrCommandError('Local branch is not bound')
3237
3238
3239
class cmd_uncommit(Command):
3240
"""Remove the last committed revision.
3241
3242
--verbose will print out what is being removed.
3243
--dry-run will go through all the motions, but not actually
3244
remove anything.
3245
3246
In the future, uncommit will create a revision bundle, which can then
3247
be re-applied.
3248
"""
3249
3250
# TODO: jam 20060108 Add an option to allow uncommit to remove
3251
# unreferenced information in 'branch-as-repository' branches.
3252
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
3253
# information in shared branches as well.
3254
_see_also = ['commit']
3255
takes_options = ['verbose', 'revision',
3256
Option('dry-run', help='Don\'t actually make changes.'),
3257
Option('force', help='Say yes to all questions.')]
3258
takes_args = ['location?']
3259
aliases = []
3260
3261
def run(self, location=None,
3262
dry_run=False, verbose=False,
3263
revision=None, force=False):
3264
from bzrlib.log import log_formatter, show_log
3265
import sys
3266
from bzrlib.uncommit import uncommit
3267
3268
if location is None:
3269
location = u'.'
3270
control, relpath = bzrdir.BzrDir.open_containing(location)
3271
try:
3272
tree = control.open_workingtree()
3273
b = tree.branch
3274
except (errors.NoWorkingTree, errors.NotLocalUrl):
3275
tree = None
3276
b = control.open_branch()
3277
3278
rev_id = None
3279
if revision is None:
3280
revno = b.revno()
3281
else:
3282
# 'bzr uncommit -r 10' actually means uncommit
3283
# so that the final tree is at revno 10.
3284
# but bzrlib.uncommit.uncommit() actually uncommits
3285
# the revisions that are supplied.
3286
# So we need to offset it by one
3287
revno = revision[0].in_history(b).revno+1
3288
3289
if revno <= b.revno():
3290
rev_id = b.get_rev_id(revno)
3291
if rev_id is None:
3292
self.outf.write('No revisions to uncommit.\n')
3293
return 1
3294
3295
lf = log_formatter('short',
3296
to_file=self.outf,
3297
show_timezone='original')
3298
3299
show_log(b,
3300
lf,
3301
verbose=False,
3302
direction='forward',
3303
start_revision=revno,
3304
end_revision=b.revno())
3305
3306
if dry_run:
3307
print 'Dry-run, pretending to remove the above revisions.'
3308
if not force:
3309
val = raw_input('Press <enter> to continue')
3310
else:
3311
print 'The above revision(s) will be removed.'
3312
if not force:
3313
val = raw_input('Are you sure [y/N]? ')
3314
if val.lower() not in ('y', 'yes'):
3315
print 'Canceled'
3316
return 0
3317
3318
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
3319
revno=revno)
3320
3321
3322
class cmd_break_lock(Command):
3323
"""Break a dead lock on a repository, branch or working directory.
3324
3325
CAUTION: Locks should only be broken when you are sure that the process
3326
holding the lock has been stopped.
3327
3328
You can get information on what locks are open via the 'bzr info' command.
3329
3330
example:
3331
bzr break-lock
3332
"""
3333
takes_args = ['location?']
3334
3335
def run(self, location=None, show=False):
3336
if location is None:
3337
location = u'.'
3338
control, relpath = bzrdir.BzrDir.open_containing(location)
3339
try:
3340
control.break_lock()
3341
except NotImplementedError:
3342
pass
3343
3344
3345
class cmd_wait_until_signalled(Command):
3346
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
3347
3348
This just prints a line to signal when it is ready, then blocks on stdin.
3349
"""
3350
3351
hidden = True
3352
3353
def run(self):
3354
sys.stdout.write("running\n")
3355
sys.stdout.flush()
3356
sys.stdin.readline()
3357
3358
3359
class cmd_serve(Command):
3360
"""Run the bzr server."""
3361
3362
aliases = ['server']
3363
3364
takes_options = [
3365
Option('inet',
3366
help='Serve on stdin/out for use from inetd or sshd.'),
3367
Option('port',
3368
help='Listen for connections on nominated port of the form '
3369
'[hostname:]portnumber. Passing 0 as the port number will '
3370
'result in a dynamically allocated port. The default port is '
3371
'4155.',
3372
type=str),
3373
Option('directory',
3374
help='Serve contents of this directory.',
3375
type=unicode),
3376
Option('allow-writes',
3377
help='By default the server is a readonly server. Supplying '
3378
'--allow-writes enables write access to the contents of '
3379
'the served directory and below.'
3380
),
3381
]
3382
3383
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3384
from bzrlib.smart import medium, server
3385
from bzrlib.transport import get_transport
3386
from bzrlib.transport.chroot import ChrootServer
3387
from bzrlib.transport.remote import BZR_DEFAULT_PORT, BZR_DEFAULT_INTERFACE
3388
if directory is None:
3389
directory = os.getcwd()
3390
url = urlutils.local_path_to_url(directory)
3391
if not allow_writes:
3392
url = 'readonly+' + url
3393
chroot_server = ChrootServer(get_transport(url))
3394
chroot_server.setUp()
3395
t = get_transport(chroot_server.get_url())
3396
if inet:
3397
smart_server = medium.SmartServerPipeStreamMedium(
3398
sys.stdin, sys.stdout, t)
3399
else:
3400
host = BZR_DEFAULT_INTERFACE
3401
if port is None:
3402
port = BZR_DEFAULT_PORT
3403
else:
3404
if ':' in port:
3405
host, port = port.split(':')
3406
port = int(port)
3407
smart_server = server.SmartTCPServer(t, host=host, port=port)
3408
print 'listening on port: ', smart_server.port
3409
sys.stdout.flush()
3410
# for the duration of this server, no UI output is permitted.
3411
# note that this may cause problems with blackbox tests. This should
3412
# be changed with care though, as we dont want to use bandwidth sending
3413
# progress over stderr to smart server clients!
3414
old_factory = ui.ui_factory
3415
try:
3416
ui.ui_factory = ui.SilentUIFactory()
3417
smart_server.serve()
3418
finally:
3419
ui.ui_factory = old_factory
3420
3421
3422
class cmd_join(Command):
3423
"""Combine a subtree into its containing tree.
3424
3425
This command is for experimental use only. It requires the target tree
3426
to be in dirstate-with-subtree format, which cannot be converted into
3427
earlier formats.
3428
3429
The TREE argument should be an independent tree, inside another tree, but
3430
not part of it. (Such trees can be produced by "bzr split", but also by
3431
running "bzr branch" with the target inside a tree.)
3432
3433
The result is a combined tree, with the subtree no longer an independant
3434
part. This is marked as a merge of the subtree into the containing tree,
3435
and all history is preserved.
3436
3437
If --reference is specified, the subtree retains its independence. It can
3438
be branched by itself, and can be part of multiple projects at the same
3439
time. But operations performed in the containing tree, such as commit
3440
and merge, will recurse into the subtree.
3441
"""
3442
3443
_see_also = ['split']
3444
takes_args = ['tree']
3445
takes_options = [
3446
Option('reference', help='Join by reference.'),
3447
]
3448
hidden = True
3449
3450
def run(self, tree, reference=False):
3451
sub_tree = WorkingTree.open(tree)
3452
parent_dir = osutils.dirname(sub_tree.basedir)
3453
containing_tree = WorkingTree.open_containing(parent_dir)[0]
3454
repo = containing_tree.branch.repository
3455
if not repo.supports_rich_root():
3456
raise errors.BzrCommandError(
3457
"Can't join trees because %s doesn't support rich root data.\n"
3458
"You can use bzr upgrade on the repository."
3459
% (repo,))
3460
if reference:
3461
try:
3462
containing_tree.add_reference(sub_tree)
3463
except errors.BadReferenceTarget, e:
3464
# XXX: Would be better to just raise a nicely printable
3465
# exception from the real origin. Also below. mbp 20070306
3466
raise errors.BzrCommandError("Cannot join %s. %s" %
3467
(tree, e.reason))
3468
else:
3469
try:
3470
containing_tree.subsume(sub_tree)
3471
except errors.BadSubsumeSource, e:
3472
raise errors.BzrCommandError("Cannot join %s. %s" %
3473
(tree, e.reason))
3474
3475
3476
class cmd_split(Command):
3477
"""Split a tree into two trees.
3478
3479
This command is for experimental use only. It requires the target tree
3480
to be in dirstate-with-subtree format, which cannot be converted into
3481
earlier formats.
3482
3483
The TREE argument should be a subdirectory of a working tree. That
3484
subdirectory will be converted into an independent tree, with its own
3485
branch. Commits in the top-level tree will not apply to the new subtree.
3486
If you want that behavior, do "bzr join --reference TREE".
3487
"""
3488
3489
_see_also = ['join']
3490
takes_args = ['tree']
3491
3492
hidden = True
3493
3494
def run(self, tree):
3495
containing_tree, subdir = WorkingTree.open_containing(tree)
3496
sub_id = containing_tree.path2id(subdir)
3497
if sub_id is None:
3498
raise errors.NotVersionedError(subdir)
3499
try:
3500
containing_tree.extract(sub_id)
3501
except errors.RootNotRich:
3502
raise errors.UpgradeRequired(containing_tree.branch.base)
3503
3504
3505
3506
class cmd_merge_directive(Command):
3507
"""Generate a merge directive for auto-merge tools.
3508
3509
A directive requests a merge to be performed, and also provides all the
3510
information necessary to do so. This means it must either include a
3511
revision bundle, or the location of a branch containing the desired
3512
revision.
3513
3514
A submit branch (the location to merge into) must be supplied the first
3515
time the command is issued. After it has been supplied once, it will
3516
be remembered as the default.
3517
3518
A public branch is optional if a revision bundle is supplied, but required
3519
if --diff or --plain is specified. It will be remembered as the default
3520
after the first use.
3521
"""
3522
3523
takes_args = ['submit_branch?', 'public_branch?']
3524
3525
takes_options = [
3526
RegistryOption.from_kwargs('patch-type',
3527
'The type of patch to include in the directive',
3528
title='Patch type',
3529
value_switches=True,
3530
enum_switch=False,
3531
bundle='Bazaar revision bundle (default).',
3532
diff='Normal unified diff.',
3533
plain='No patch, just directive.'),
3534
Option('sign', help='GPG-sign the directive.'), 'revision',
3535
Option('mail-to', type=str,
3536
help='Instead of printing the directive, email to this address.'),
3537
Option('message', type=str, short_name='m',
3538
help='Message to use when committing this merge.')
3539
]
3540
3541
encoding_type = 'exact'
3542
3543
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
3544
sign=False, revision=None, mail_to=None, message=None):
3545
from bzrlib.revision import ensure_null, NULL_REVISION
3546
if patch_type == 'plain':
3547
patch_type = None
3548
branch = Branch.open('.')
3549
stored_submit_branch = branch.get_submit_branch()
3550
if submit_branch is None:
3551
submit_branch = stored_submit_branch
3552
else:
3553
if stored_submit_branch is None:
3554
branch.set_submit_branch(submit_branch)
3555
if submit_branch is None:
3556
submit_branch = branch.get_parent()
3557
if submit_branch is None:
3558
raise errors.BzrCommandError('No submit branch specified or known')
3559
3560
stored_public_branch = branch.get_public_branch()
3561
if public_branch is None:
3562
public_branch = stored_public_branch
3563
elif stored_public_branch is None:
3564
branch.set_public_branch(public_branch)
3565
if patch_type != "bundle" and public_branch is None:
3566
raise errors.BzrCommandError('No public branch specified or'
3567
' known')
3568
if revision is not None:
3569
if len(revision) != 1:
3570
raise errors.BzrCommandError('bzr merge-directive takes '
3571
'exactly one revision identifier')
3572
else:
3573
revision_id = revision[0].in_history(branch).rev_id
3574
else:
3575
revision_id = branch.last_revision()
3576
revision_id = ensure_null(revision_id)
3577
if revision_id == NULL_REVISION:
3578
raise errors.BzrCommandError('No revisions to bundle.')
3579
directive = merge_directive.MergeDirective.from_objects(
3580
branch.repository, revision_id, time.time(),
3581
osutils.local_time_offset(), submit_branch,
3582
public_branch=public_branch, patch_type=patch_type,
3583
message=message)
3584
if mail_to is None:
3585
if sign:
3586
self.outf.write(directive.to_signed(branch))
3587
else:
3588
self.outf.writelines(directive.to_lines())
3589
else:
3590
message = directive.to_email(mail_to, branch, sign)
3591
s = SMTPConnection(branch.get_config())
3592
s.send_email(message)
3593
3594
3595
class cmd_tag(Command):
3596
"""Create a tag naming a revision.
3597
3598
Tags give human-meaningful names to revisions. Commands that take a -r
3599
(--revision) option can be given -rtag:X, where X is any previously
3600
created tag.
3601
3602
Tags are stored in the branch. Tags are copied from one branch to another
3603
along when you branch, push, pull or merge.
3604
3605
It is an error to give a tag name that already exists unless you pass
3606
--force, in which case the tag is moved to point to the new revision.
3607
"""
3608
3609
_see_also = ['commit', 'tags']
3610
takes_args = ['tag_name']
3611
takes_options = [
3612
Option('delete',
3613
help='Delete this tag rather than placing it.',
3614
),
3615
Option('directory',
3616
help='Branch in which to place the tag.',
3617
short_name='d',
3618
type=unicode,
3619
),
3620
Option('force',
3621
help='Replace existing tags.',
3622
),
3623
'revision',
3624
]
3625
3626
def run(self, tag_name,
3627
delete=None,
3628
directory='.',
3629
force=None,
3630
revision=None,
3631
):
3632
branch, relpath = Branch.open_containing(directory)
3633
branch.lock_write()
3634
try:
3635
if delete:
3636
branch.tags.delete_tag(tag_name)
3637
self.outf.write('Deleted tag %s.\n' % tag_name)
3638
else:
3639
if revision:
3640
if len(revision) != 1:
3641
raise errors.BzrCommandError(
3642
"Tags can only be placed on a single revision, "
3643
"not on a range")
3644
revision_id = revision[0].in_history(branch).rev_id
3645
else:
3646
revision_id = branch.last_revision()
3647
if (not force) and branch.tags.has_tag(tag_name):
3648
raise errors.TagAlreadyExists(tag_name)
3649
branch.tags.set_tag(tag_name, revision_id)
3650
self.outf.write('Created tag %s.\n' % tag_name)
3651
finally:
3652
branch.unlock()
3653
3654
3655
class cmd_tags(Command):
3656
"""List tags.
3657
3658
This tag shows a table of tag names and the revisions they reference.
3659
"""
3660
3661
_see_also = ['tag']
3662
takes_options = [
3663
Option('directory',
3664
help='Branch whose tags should be displayed.',
3665
short_name='d',
3666
type=unicode,
3667
),
3668
]
3669
3670
@display_command
3671
def run(self,
3672
directory='.',
3673
):
3674
branch, relpath = Branch.open_containing(directory)
3675
for tag_name, target in sorted(branch.tags.get_tag_dict().items()):
3676
self.outf.write('%-20s %s\n' % (tag_name, target))
3677
3678
3679
# command-line interpretation helper for merge-related commands
3680
def _merge_helper(other_revision, base_revision,
3681
check_clean=True, ignore_zero=False,
3682
this_dir=None, backup_files=False,
3683
merge_type=None,
3684
file_list=None, show_base=False, reprocess=False,
3685
pull=False,
3686
pb=DummyProgress(),
3687
change_reporter=None,
3688
other_rev_id=None):
3689
"""Merge changes into a tree.
3690
3691
base_revision
3692
list(path, revno) Base for three-way merge.
3693
If [None, None] then a base will be automatically determined.
3694
other_revision
3695
list(path, revno) Other revision for three-way merge.
3696
this_dir
3697
Directory to merge changes into; '.' by default.
3698
check_clean
3699
If true, this_dir must have no uncommitted changes before the
3700
merge begins.
3701
ignore_zero - If true, suppress the "zero conflicts" message when
3702
there are no conflicts; should be set when doing something we expect
3703
to complete perfectly.
3704
file_list - If supplied, merge only changes to selected files.
3705
3706
All available ancestors of other_revision and base_revision are
3707
automatically pulled into the branch.
3708
3709
The revno may be -1 to indicate the last revision on the branch, which is
3710
the typical case.
3711
3712
This function is intended for use from the command line; programmatic
3713
clients might prefer to call merge.merge_inner(), which has less magic
3714
behavior.
3715
"""
3716
# Loading it late, so that we don't always have to import bzrlib.merge
3717
if merge_type is None:
3718
merge_type = _mod_merge.Merge3Merger
3719
if this_dir is None:
3720
this_dir = u'.'
3721
this_tree = WorkingTree.open_containing(this_dir)[0]
3722
if show_base and not merge_type is _mod_merge.Merge3Merger:
3723
raise errors.BzrCommandError("Show-base is not supported for this merge"
3724
" type. %s" % merge_type)
3725
if reprocess and not merge_type.supports_reprocess:
3726
raise errors.BzrCommandError("Conflict reduction is not supported for merge"
3727
" type %s." % merge_type)
3728
if reprocess and show_base:
3729
raise errors.BzrCommandError("Cannot do conflict reduction and show base.")
3730
# TODO: jam 20070226 We should really lock these trees earlier. However, we
3731
# only want to take out a lock_tree_write() if we don't have to pull
3732
# any ancestry. But merge might fetch ancestry in the middle, in
3733
# which case we would need a lock_write().
3734
# Because we cannot upgrade locks, for now we live with the fact that
3735
# the tree will be locked multiple times during a merge. (Maybe
3736
# read-only some of the time, but it means things will get read
3737
# multiple times.)
3738
try:
3739
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
3740
pb=pb, change_reporter=change_reporter)
3741
merger.pp = ProgressPhase("Merge phase", 5, pb)
3742
merger.pp.next_phase()
3743
merger.check_basis(check_clean)
3744
if other_rev_id is not None:
3745
merger.set_other_revision(other_rev_id, this_tree.branch)
3746
else:
3747
merger.set_other(other_revision)
3748
merger.pp.next_phase()
3749
merger.set_base(base_revision)
3750
if merger.base_rev_id == merger.other_rev_id:
3751
note('Nothing to do.')
3752
return 0
3753
if file_list is None:
3754
if pull and merger.base_rev_id == merger.this_rev_id:
3755
# FIXME: deduplicate with pull
3756
result = merger.this_tree.pull(merger.this_branch,
3757
False, merger.other_rev_id)
3758
if result.old_revid == result.new_revid:
3759
note('No revisions to pull.')
3760
else:
3761
note('Now on revision %d.' % result.new_revno)
3762
return 0
3763
merger.backup_files = backup_files
3764
merger.merge_type = merge_type
3765
merger.set_interesting_files(file_list)
3766
merger.show_base = show_base
3767
merger.reprocess = reprocess
3768
conflicts = merger.do_merge()
3769
if file_list is None:
3770
merger.set_pending()
3771
finally:
3772
pb.clear()
3773
return conflicts
3774
3775
3776
def _create_prefix(cur_transport):
3777
needed = [cur_transport]
3778
# Recurse upwards until we can create a directory successfully
3779
while True:
3780
new_transport = cur_transport.clone('..')
3781
if new_transport.base == cur_transport.base:
3782
raise errors.BzrCommandError("Failed to create path"
3783
" prefix for %s."
3784
% location)
3785
try:
3786
new_transport.mkdir('.')
3787
except errors.NoSuchFile:
3788
needed.append(new_transport)
3789
cur_transport = new_transport
3790
else:
3791
break
3792
3793
# Now we only need to create child directories
3794
while needed:
3795
cur_transport = needed.pop()
3796
cur_transport.ensure_base()
3797
3798
# Compatibility
3799
merge = _merge_helper
3800
3801
3802
# these get imported and then picked up by the scan for cmd_*
3803
# TODO: Some more consistent way to split command definitions across files;
3804
# we do need to load at least some information about them to know of
3805
# aliases. ideally we would avoid loading the implementation until the
3806
# details were needed.
3807
from bzrlib.cmd_version_info import cmd_version_info
3808
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
3809
from bzrlib.bundle.commands import cmd_bundle_revisions
3810
from bzrlib.sign_my_commits import cmd_sign_my_commits
3811
from bzrlib.weave_commands import cmd_versionedfile_list, cmd_weave_join, \
3812
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0