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