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