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