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