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