« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 2053
- compare with another revision
- download diff
- download tarball
- view history from revision 2053
- Committer: Canonical.com Patch Queue Manager
- Date: 2006-09-29 15:31:52 UTC
- mfrom: (2052.1.1 jam-integration)
- Revision ID: pqm@pqm.ubuntu.com-20060929153152-9a32a9b020e0f74b
Lukáš Lalinský: Windows-speficic smart server transport selftest fixes.
- files added:
- BRANCH.TODO
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/plugins/launchpad
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/intertree_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport/http
- bzrlib/version_info_formats
- tools/doc_generate
- tools/win32
- files removed:
- bzrlib/clone.py
- bzrlib/util/urlgrabber
- notes
- patches
- files renamed:
- bzrlib/changeset.py => bzrlib/bundle/__init__.py
- bzrlib/store/weave.py => bzrlib/store/versioned/__init__.py
- bzrlib/tests/test_annotate.py => bzrlib/tests/blackbox/test_annotate.py
- bzrlib/tests/test_revision_info.py => bzrlib/tests/blackbox/test_revision_info.py
- bzrlib/tests/test_status.py => bzrlib/tests/blackbox/test_status.py
- bzrlib/tests/test_uncommit.py => bzrlib/tests/blackbox/test_uncommit.py
- bzrlib/tests/test_branch.py => bzrlib/tests/branch_implementations/test_branch.py
- bzrlib/tests/test_parent.py => bzrlib/tests/branch_implementations/test_parent.py
- bzrlib/tests/test_revprops.py => bzrlib/tests/repository_implementations/test_revision.py
- bzrlib/tests/test_sftp.py => bzrlib/tests/test_sftp_transport.py
- bzrlib/transport/http.py => bzrlib/transport/http/__init__.py
- bzrlib/xml.py => bzrlib/xml_serializer.py
- tutorial.txt => doc/tutorial.txt
- bzr_man.py => tools/doc_generate/autodoc_man.py
- files modified:
- .bzrignore
- setup.py *
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005 by Canonical Ltd
2
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
# DO NOT change this to cStringIO - it results in control files
18
# written as UCS4
19
# FIXIT! (Only deal with byte streams OR unicode at any one layer.)
20
# RBC 20051018
21
from StringIO import StringIO
17
"""builtin bzr commands"""
18
19
20
import codecs
21
import errno
22
import os
23
import os.path
22
24
import sys
23
import os
24
25
25
26
import bzrlib
26
from bzrlib import BZRDIR
27
from bzrlib import (
28
branch,
29
bundle,
30
bzrdir,
31
config,
32
errors,
33
ignores,
34
log,
35
osutils,
36
repository,
37
transport,
38
ui,
39
urlutils,
40
)
41
from bzrlib.branch import Branch, BranchReferenceFormat
42
from bzrlib.bundle import read_bundle_from_url
43
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
44
from bzrlib.conflicts import ConflictList
27
45
from bzrlib.commands import Command, display_command
28
from bzrlib.branch import Branch
29
from bzrlib.revision import common_ancestor
30
import bzrlib.errors as errors
31
46
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
32
47
NotBranchError, DivergedBranches, NotConflicted,
33
NoSuchFile, NoWorkingTree, FileInWrongBranch)
48
NoSuchFile, NoWorkingTree, FileInWrongBranch,
49
NotVersionedError, NotABundle)
50
from bzrlib.merge import Merge3Merger
34
51
from bzrlib.option import Option
52
from bzrlib.progress import DummyProgress, ProgressPhase
53
from bzrlib.revision import common_ancestor
35
54
from bzrlib.revisionspec import RevisionSpec
36
import bzrlib.trace
37
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
55
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
56
from bzrlib.transport.local import LocalTransport
57
import bzrlib.tree
38
58
from bzrlib.workingtree import WorkingTree
39
59
40
60
45
65
raise BzrCommandError("%s is not in the same branch as %s" %
46
66
(e.path, file_list[0]))
47
67
68
69
# XXX: Bad function name; should possibly also be a class method of
70
# WorkingTree rather than a function.
48
71
def internal_tree_files(file_list, default_branch=u'.'):
49
"""\
50
Return a branch and list of branch-relative paths.
51
If supplied file_list is empty or None, the branch default will be used,
52
and returned file_list will match the original.
72
"""Convert command-line paths to a WorkingTree and relative paths.
73
74
This is typically used for command-line processors that take one or
75
more filenames, and infer the workingtree that contains them.
76
77
The filenames given are not required to exist.
78
79
:param file_list: Filenames to convert.
80
81
:param default_branch: Fallback tree path to use if file_list is empty or None.
82
83
:return: workingtree, [relative_paths]
53
84
"""
54
85
if file_list is None or len(file_list) == 0:
55
86
return WorkingTree.open_containing(default_branch)[0], file_list
63
94
return tree, new_list
64
95
65
96
97
def get_format_type(typestring):
98
"""Parse and return a format specifier."""
99
if typestring == "weave":
100
return bzrdir.BzrDirFormat6()
101
if typestring == "default":
102
return bzrdir.BzrDirMetaFormat1()
103
if typestring == "metaweave":
104
format = bzrdir.BzrDirMetaFormat1()
105
format.repository_format = repository.RepositoryFormat7()
106
return format
107
if typestring == "knit":
108
format = bzrdir.BzrDirMetaFormat1()
109
format.repository_format = repository.RepositoryFormatKnit1()
110
return format
111
if typestring == "experimental-knit2":
112
format = bzrdir.BzrDirMetaFormat1()
113
format.repository_format = repository.RepositoryFormatKnit2()
114
return format
115
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
116
"metaweave and weave" % typestring
117
raise BzrCommandError(msg)
118
119
66
120
# TODO: Make sure no commands unconditionally use the working directory as a
67
121
# branch. If a filename argument is used, the first of them should be used to
68
122
# specify the branch. (Perhaps this can be factored out into some kind of
90
144
modified
91
145
Text has changed since the previous revision.
92
146
93
unchanged
94
Nothing about this file has changed since the previous revision.
95
Only shown with --all.
96
97
147
unknown
98
148
Not versioned and not matching an ignore pattern.
99
149
112
162
# TODO: --no-recurse, --recurse options
113
163
114
164
takes_args = ['file*']
115
takes_options = ['all', 'show-ids', 'revision']
165
takes_options = ['show-ids', 'revision']
116
166
aliases = ['st', 'stat']
167
168
encoding_type = 'replace'
117
169
118
170
@display_command
119
def run(self, all=False, show_ids=False, file_list=None, revision=None):
171
def run(self, show_ids=False, file_list=None, revision=None):
172
from bzrlib.status import show_tree_status
173
120
174
tree, file_list = tree_files(file_list)
121
175
122
from bzrlib.status import show_status
123
show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
124
specific_files=file_list, revision=revision)
176
show_tree_status(tree, show_ids=show_ids,
177
specific_files=file_list, revision=revision,
178
to_file=self.outf)
125
179
126
180
127
181
class cmd_cat_revision(Command):
134
188
hidden = True
135
189
takes_args = ['revision_id?']
136
190
takes_options = ['revision']
191
# cat-revision is more for frontends so should be exact
192
encoding = 'strict'
137
193
138
194
@display_command
139
195
def run(self, revision_id=None, revision=None):
143
199
if revision_id is None and revision is None:
144
200
raise BzrCommandError('You must supply either --revision or a revision_id')
145
201
b = WorkingTree.open_containing(u'.')[0].branch
202
203
# TODO: jam 20060112 should cat-revision always output utf-8?
146
204
if revision_id is not None:
147
sys.stdout.write(b.get_revision_xml(revision_id))
205
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
148
206
elif revision is not None:
149
207
for rev in revision:
150
208
if rev is None:
151
209
raise BzrCommandError('You cannot specify a NULL revision.')
152
210
revno, rev_id = rev.in_history(b)
153
sys.stdout.write(b.get_revision_xml(rev_id))
211
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
154
212
155
213
156
214
class cmd_revno(Command):
157
215
"""Show current revision number.
158
216
159
This is equal to the number of revisions on this branch."""
217
This is equal to the number of revisions on this branch.
218
"""
219
160
220
takes_args = ['location?']
221
161
222
@display_command
162
223
def run(self, location=u'.'):
163
print Branch.open_containing(location)[0].revno()
224
self.outf.write(str(Branch.open_containing(location)[0].revno()))
225
self.outf.write('\n')
164
226
165
227
166
228
class cmd_revision_info(Command):
169
231
hidden = True
170
232
takes_args = ['revision_info*']
171
233
takes_options = ['revision']
234
172
235
@display_command
173
236
def run(self, revision=None, revision_info_list=[]):
174
237
177
240
revs.extend(revision)
178
241
if revision_info_list is not None:
179
242
for rev in revision_info_list:
180
revs.append(RevisionSpec(rev))
243
revs.append(RevisionSpec.from_string(rev))
181
244
if len(revs) == 0:
182
245
raise BzrCommandError('You must supply a revision identifier')
183
246
211
274
212
275
Adding a file whose parent directory is not versioned will
213
276
implicitly add the parent, and so on up to the root. This means
214
you should never need to explictly add a directory, they'll just
277
you should never need to explicitly add a directory, they'll just
215
278
get added when you add a file in the directory.
279
280
--dry-run will show which files would be added, but not actually
281
add them.
282
283
--file-ids-from will try to use the file ids from the supplied path.
284
It looks up ids trying to find a matching parent directory with the
285
same filename, and then by pure path.
216
286
"""
217
287
takes_args = ['file*']
218
takes_options = ['no-recurse']
219
220
def run(self, file_list, no_recurse=False):
221
from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
222
if is_quiet():
223
reporter = add_reporter_null
288
takes_options = ['no-recurse', 'dry-run', 'verbose',
289
Option('file-ids-from', type=unicode,
290
help='Lookup file ids from here')]
291
encoding_type = 'replace'
292
293
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
294
file_ids_from=None):
295
import bzrlib.add
296
297
if file_ids_from is not None:
298
try:
299
base_tree, base_path = WorkingTree.open_containing(
300
file_ids_from)
301
except errors.NoWorkingTree:
302
base_branch, base_path = branch.Branch.open_containing(
303
file_ids_from)
304
base_tree = base_branch.basis_tree()
305
306
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
307
to_file=self.outf, should_print=(not is_quiet()))
224
308
else:
225
reporter = add_reporter_print
226
smart_add(file_list, not no_recurse, reporter)
309
action = bzrlib.add.AddAction(to_file=self.outf,
310
should_print=(not is_quiet()))
311
312
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
313
action=action, save=not dry_run)
314
if len(ignored) > 0:
315
if verbose:
316
for glob in sorted(ignored.keys()):
317
for path in ignored[glob]:
318
self.outf.write("ignored %s matching \"%s\"\n"
319
% (path, glob))
320
else:
321
match_len = 0
322
for glob, paths in ignored.items():
323
match_len += len(paths)
324
self.outf.write("ignored %d file(s).\n" % match_len)
325
self.outf.write("If you wish to add some of these files,"
326
" please add them by name.\n")
227
327
228
328
229
329
class cmd_mkdir(Command):
231
331
232
332
This is equivalent to creating the directory and then adding it.
233
333
"""
334
234
335
takes_args = ['dir+']
336
encoding_type = 'replace'
235
337
236
338
def run(self, dir_list):
237
339
for d in dir_list:
238
340
os.mkdir(d)
239
341
wt, dd = WorkingTree.open_containing(d)
240
342
wt.add([dd])
241
print 'added', d
343
self.outf.write('added %s\n' % d)
242
344
243
345
244
346
class cmd_relpath(Command):
245
347
"""Show path of a file relative to root"""
348
246
349
takes_args = ['filename']
247
350
hidden = True
248
351
249
352
@display_command
250
353
def run(self, filename):
354
# TODO: jam 20050106 Can relpath return a munged path if
355
# sys.stdout encoding cannot represent it?
251
356
tree, relpath = WorkingTree.open_containing(filename)
252
print relpath
357
self.outf.write(relpath)
358
self.outf.write('\n')
253
359
254
360
255
361
class cmd_inventory(Command):
256
362
"""Show inventory of the current working copy or a revision.
257
363
258
364
It is possible to limit the output to a particular entry
259
type using the --kind option. For example; --kind file.
365
type using the --kind option. For example: --kind file.
366
367
It is also possible to restrict the list of files to a specific
368
set. For example: bzr inventory --show-ids this/file
260
369
"""
370
261
371
takes_options = ['revision', 'show-ids', 'kind']
262
372
takes_args = ['file*']
373
263
374
@display_command
264
def run(self, revision=None, show_ids=False, kind=None):
375
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
265
376
if kind and kind not in ['file', 'directory', 'symlink']:
266
377
raise BzrCommandError('invalid kind specified')
267
tree = WorkingTree.open_containing(u'.')[0]
268
if revision is None:
269
inv = tree.read_working_inventory()
270
else:
378
379
work_tree, file_list = tree_files(file_list)
380
381
if revision is not None:
271
382
if len(revision) > 1:
272
383
raise BzrCommandError('bzr inventory --revision takes'
273
' exactly one revision identifier')
274
inv = tree.branch.get_revision_inventory(
275
revision[0].in_history(tree.branch).rev_id)
276
277
for path, entry in inv.entries():
384
' exactly one revision identifier')
385
revision_id = revision[0].in_history(work_tree.branch).rev_id
386
tree = work_tree.branch.repository.revision_tree(revision_id)
387
388
# We include work_tree as well as 'tree' here
389
# So that doing '-r 10 path/foo' will lookup whatever file
390
# exists now at 'path/foo' even if it has been renamed, as
391
# well as whatever files existed in revision 10 at path/foo
392
trees = [tree, work_tree]
393
else:
394
tree = work_tree
395
trees = [tree]
396
397
if file_list is not None:
398
file_ids = bzrlib.tree.find_ids_across_trees(file_list, trees,
399
require_versioned=True)
400
# find_ids_across_trees may include some paths that don't
401
# exist in 'tree'.
402
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
403
for file_id in file_ids if file_id in tree)
404
else:
405
entries = tree.inventory.entries()
406
407
for path, entry in entries:
278
408
if kind and kind != entry.kind:
279
409
continue
280
410
if show_ids:
281
print '%-50s %s' % (path, entry.file_id)
411
self.outf.write('%-50s %s\n' % (path, entry.file_id))
282
412
else:
283
print path
284
285
286
class cmd_move(Command):
287
"""Move files to a different directory.
288
289
examples:
290
bzr move *.txt doc
291
292
The destination must be a versioned directory in the same branch.
293
"""
294
takes_args = ['source$', 'dest']
295
def run(self, source_list, dest):
296
tree, source_list = tree_files(source_list)
297
# TODO: glob expansion on windows?
298
tree.move(source_list, tree.relpath(dest))
299
300
301
class cmd_rename(Command):
302
"""Change the name of an entry.
303
304
examples:
305
bzr rename frob.c frobber.c
306
bzr rename src/frob.c lib/frob.c
307
308
It is an error if the destination name exists.
309
310
See also the 'move' command, which moves files into a different
311
directory without changing their name.
312
"""
313
# TODO: Some way to rename multiple files without invoking
314
# bzr for each one?"""
315
takes_args = ['from_name', 'to_name']
316
317
def run(self, from_name, to_name):
318
tree, (from_name, to_name) = tree_files((from_name, to_name))
319
tree.rename_one(from_name, to_name)
413
self.outf.write(path)
414
self.outf.write('\n')
320
415
321
416
322
417
class cmd_mv(Command):
332
427
333
428
Files cannot be moved between branches.
334
429
"""
430
335
431
takes_args = ['names*']
432
aliases = ['move', 'rename']
433
encoding_type = 'replace'
434
336
435
def run(self, names_list):
436
if names_list is None:
437
names_list = []
438
337
439
if len(names_list) < 2:
338
440
raise BzrCommandError("missing file argument")
339
441
tree, rel_names = tree_files(names_list)
341
443
if os.path.isdir(names_list[-1]):
342
444
# move into existing directory
343
445
for pair in tree.move(rel_names[:-1], rel_names[-1]):
344
print "%s => %s" % pair
446
self.outf.write("%s => %s\n" % pair)
345
447
else:
346
448
if len(names_list) != 2:
347
449
raise BzrCommandError('to mv multiple files the destination '
348
450
'must be a versioned directory')
349
451
tree.rename_one(rel_names[0], rel_names[1])
350
print "%s => %s" % (rel_names[0], rel_names[1])
452
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
351
453
352
454
353
455
class cmd_pull(Command):
354
"""Pull any changes from another branch into the current one.
355
356
If there is no default location set, the first pull will set it. After
357
that, you can omit the location to use the default. To change the
358
default, use --remember.
456
"""Turn this branch into a mirror of another branch.
359
457
360
458
This command only works on branches that have not diverged. Branches are
361
considered diverged if both branches have had commits without first
362
pulling from the other.
459
considered diverged if the destination branch's most recent commit is one
460
that has not been merged (directly or indirectly) into the parent.
363
461
364
If branches have diverged, you can use 'bzr merge' to pull the text changes
462
If branches have diverged, you can use 'bzr merge' to integrate the changes
365
463
from one into the other. Once one branch has merged, the other should
366
464
be able to pull it again.
367
465
368
466
If you want to forget your local changes and just update your branch to
369
match the remote one, use --overwrite.
467
match the remote one, use pull --overwrite.
468
469
If there is no default location set, the first pull will set it. After
470
that, you can omit the location to use the default. To change the
471
default, use --remember. The value will only be saved if the remote
472
location can be accessed.
370
473
"""
371
takes_options = ['remember', 'overwrite', 'verbose']
474
475
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
372
476
takes_args = ['location?']
373
374
def run(self, location=None, remember=False, overwrite=False, verbose=False):
375
from bzrlib.merge import merge
376
from shutil import rmtree
377
import errno
378
# FIXME: too much stuff is in the command class
379
tree_to = WorkingTree.open_containing(u'.')[0]
380
stored_loc = tree_to.branch.get_parent()
477
encoding_type = 'replace'
478
479
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
480
# FIXME: too much stuff is in the command class
481
try:
482
tree_to = WorkingTree.open_containing(u'.')[0]
483
branch_to = tree_to.branch
484
except NoWorkingTree:
485
tree_to = None
486
branch_to = Branch.open_containing(u'.')[0]
487
488
reader = None
489
if location is not None:
490
try:
491
reader = bundle.read_bundle_from_url(location)
492
except NotABundle:
493
pass # Continue on considering this url a Branch
494
495
stored_loc = branch_to.get_parent()
381
496
if location is None:
382
497
if stored_loc is None:
383
498
raise BzrCommandError("No pull location known or specified.")
384
499
else:
385
print "Using saved location: %s" % stored_loc
500
display_url = urlutils.unescape_for_display(stored_loc,
501
self.outf.encoding)
502
self.outf.write("Using saved location: %s\n" % display_url)
386
503
location = stored_loc
387
504
388
br_from = Branch.open(location)
389
br_to = tree_to.branch
390
391
old_rh = br_to.revision_history()
392
count = tree_to.pull(br_from, overwrite)
393
394
if br_to.get_parent() is None or remember:
395
br_to.set_parent(location)
505
506
if reader is not None:
507
install_bundle(branch_to.repository, reader)
508
branch_from = branch_to
509
else:
510
branch_from = Branch.open(location)
511
512
if branch_to.get_parent() is None or remember:
513
branch_to.set_parent(branch_from.base)
514
515
rev_id = None
516
if revision is None:
517
if reader is not None:
518
rev_id = reader.target
519
elif len(revision) == 1:
520
rev_id = revision[0].in_history(branch_from).rev_id
521
else:
522
raise BzrCommandError('bzr pull --revision takes one value.')
523
524
old_rh = branch_to.revision_history()
525
if tree_to is not None:
526
count = tree_to.pull(branch_from, overwrite, rev_id)
527
else:
528
count = branch_to.pull(branch_from, overwrite, rev_id)
396
529
note('%d revision(s) pulled.' % (count,))
397
530
398
531
if verbose:
399
new_rh = tree_to.branch.revision_history()
532
new_rh = branch_to.revision_history()
400
533
if old_rh != new_rh:
401
534
# Something changed
402
535
from bzrlib.log import show_changed_revisions
403
show_changed_revisions(tree_to.branch, old_rh, new_rh)
536
show_changed_revisions(branch_to, old_rh, new_rh,
537
to_file=self.outf)
404
538
405
539
406
540
class cmd_push(Command):
407
"""Push this branch into another branch.
408
409
The remote branch will not have its working tree populated because this
410
is both expensive, and may not be supported on the remote file system.
411
412
Some smart servers or protocols *may* put the working tree in place.
541
"""Update a mirror of this branch.
542
543
The target branch will not have its working tree populated because this
544
is both expensive, and is not supported on remote file systems.
545
546
Some smart servers or protocols *may* put the working tree in place in
547
the future.
548
549
This command only works on branches that have not diverged. Branches are
550
considered diverged if the destination branch's most recent commit is one
551
that has not been merged (directly or indirectly) by the source branch.
552
553
If branches have diverged, you can use 'bzr push --overwrite' to replace
554
the other branch completely, discarding its unmerged changes.
555
556
If you want to ensure you have the different changes in the other branch,
557
do a merge (see bzr help merge) from the other branch, and commit that.
558
After that you will be able to do a push without '--overwrite'.
413
559
414
560
If there is no default push location set, the first push will set it.
415
561
After that, you can omit the location to use the default. To change the
416
default, use --remember.
417
418
This command only works on branches that have not diverged. Branches are
419
considered diverged if the branch being pushed to is not an older version
420
of this branch.
421
422
If branches have diverged, you can use 'bzr push --overwrite' to replace
423
the other branch completely.
424
425
If you want to ensure you have the different changes in the other branch,
426
do a merge (see bzr help merge) from the other branch, and commit that
427
before doing a 'push --overwrite'.
562
default, use --remember. The value will only be saved if the remote
563
location can be accessed.
428
564
"""
429
takes_options = ['remember', 'overwrite',
565
566
takes_options = ['remember', 'overwrite', 'verbose',
430
567
Option('create-prefix',
431
568
help='Create the path leading up to the branch '
432
569
'if it does not already exist')]
433
570
takes_args = ['location?']
571
encoding_type = 'replace'
434
572
435
573
def run(self, location=None, remember=False, overwrite=False,
436
574
create_prefix=False, verbose=False):
437
575
# FIXME: Way too big! Put this into a function called from the
438
576
# command.
439
import errno
440
from shutil import rmtree
441
from bzrlib.transport import get_transport
442
577
443
tree_from = WorkingTree.open_containing(u'.')[0]
444
br_from = tree_from.branch
445
stored_loc = tree_from.branch.get_push_location()
578
br_from = Branch.open_containing('.')[0]
579
stored_loc = br_from.get_push_location()
446
580
if location is None:
447
581
if stored_loc is None:
448
582
raise BzrCommandError("No push location known or specified.")
449
583
else:
450
print "Using saved location: %s" % stored_loc
584
display_url = urlutils.unescape_for_display(stored_loc,
585
self.outf.encoding)
586
self.outf.write("Using saved location: %s\n" % display_url)
451
587
location = stored_loc
588
589
to_transport = transport.get_transport(location)
590
location_url = to_transport.base
591
592
old_rh = []
452
593
try:
453
br_to = Branch.open(location)
594
dir_to = bzrdir.BzrDir.open(location_url)
595
br_to = dir_to.open_branch()
454
596
except NotBranchError:
455
597
# create a branch.
456
transport = get_transport(location).clone('..')
598
to_transport = to_transport.clone('..')
457
599
if not create_prefix:
458
600
try:
459
transport.mkdir(transport.relpath(location))
601
relurl = to_transport.relpath(location_url)
602
mutter('creating directory %s => %s', location_url, relurl)
603
to_transport.mkdir(relurl)
460
604
except NoSuchFile:
461
605
raise BzrCommandError("Parent directory of %s "
462
606
"does not exist." % location)
463
607
else:
464
current = transport.base
465
needed = [(transport, transport.relpath(location))]
608
current = to_transport.base
609
needed = [(to_transport, to_transport.relpath(location_url))]
466
610
while needed:
467
611
try:
468
transport, relpath = needed[-1]
469
transport.mkdir(relpath)
612
to_transport, relpath = needed[-1]
613
to_transport.mkdir(relpath)
470
614
needed.pop()
471
615
except NoSuchFile:
472
new_transport = transport.clone('..')
616
new_transport = to_transport.clone('..')
473
617
needed.append((new_transport,
474
new_transport.relpath(transport.base)))
475
if new_transport.base == transport.base:
476
raise BzrCommandError("Could not creeate "
618
new_transport.relpath(to_transport.base)))
619
if new_transport.base == to_transport.base:
620
raise BzrCommandError("Could not create "
477
621
"path prefix.")
478
br_to = Branch.initialize(location)
479
old_rh = br_to.revision_history()
480
try:
622
dir_to = br_from.bzrdir.clone(location_url,
623
revision_id=br_from.last_revision())
624
br_to = dir_to.open_branch()
625
count = len(br_to.revision_history())
626
# We successfully created the target, remember it
627
if br_from.get_push_location() is None or remember:
628
br_from.set_push_location(br_to.base)
629
else:
630
# We were able to connect to the remote location, so remember it
631
# we don't need to successfully push because of possible divergence.
632
if br_from.get_push_location() is None or remember:
633
br_from.set_push_location(br_to.base)
634
old_rh = br_to.revision_history()
481
635
try:
482
tree_to = br_to.working_tree()
483
except NoWorkingTree:
484
# TODO: This should be updated for branches which don't have a
485
# working tree, as opposed to ones where we just couldn't
486
# update the tree.
487
warning('Unable to update the working tree of: %s' % (br_to.base,))
488
count = br_to.pull(br_from, overwrite)
489
else:
490
count = tree_to.pull(br_from, overwrite)
491
except DivergedBranches:
492
raise BzrCommandError("These branches have diverged."
493
" Try a merge then push with overwrite.")
494
if br_from.get_push_location() is None or remember:
495
br_from.set_push_location(location)
636
try:
637
tree_to = dir_to.open_workingtree()
638
except errors.NotLocalUrl:
639
warning('This transport does not update the working '
640
'tree of: %s' % (br_to.base,))
641
count = br_to.pull(br_from, overwrite)
642
except NoWorkingTree:
643
count = br_to.pull(br_from, overwrite)
644
else:
645
count = tree_to.pull(br_from, overwrite)
646
except DivergedBranches:
647
raise BzrCommandError("These branches have diverged."
648
" Try a merge then push with overwrite.")
496
649
note('%d revision(s) pushed.' % (count,))
497
650
498
651
if verbose:
500
653
if old_rh != new_rh:
501
654
# Something changed
502
655
from bzrlib.log import show_changed_revisions
503
show_changed_revisions(br_to, old_rh, new_rh)
656
show_changed_revisions(br_to, old_rh, new_rh,
657
to_file=self.outf)
504
658
505
659
506
660
class cmd_branch(Command):
521
675
aliases = ['get', 'clone']
522
676
523
677
def run(self, from_location, to_location=None, revision=None, basis=None):
524
from bzrlib.clone import copy_branch
525
import errno
526
from shutil import rmtree
527
678
if revision is None:
528
679
revision = [None]
529
680
elif len(revision) > 1:
540
691
br_from.lock_read()
541
692
try:
542
693
if basis is not None:
543
basis_branch = WorkingTree.open_containing(basis)[0].branch
694
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
544
695
else:
545
basis_branch = None
696
basis_dir = None
546
697
if len(revision) == 1 and revision[0] is not None:
547
698
revision_id = revision[0].in_history(br_from)[1]
548
699
else:
549
revision_id = None
700
# FIXME - wt.last_revision, fallback to branch, fall back to
701
# None or perhaps NULL_REVISION to mean copy nothing
702
# RBC 20060209
703
revision_id = br_from.last_revision()
550
704
if to_location is None:
551
705
to_location = os.path.basename(from_location.rstrip("/\\"))
552
706
name = None
553
707
else:
554
708
name = os.path.basename(to_location) + '\n'
555
try:
556
os.mkdir(to_location)
557
except OSError, e:
558
if e.errno == errno.EEXIST:
559
raise BzrCommandError('Target directory "%s" already'
560
' exists.' % to_location)
561
if e.errno == errno.ENOENT:
562
raise BzrCommandError('Parent of "%s" does not exist.' %
563
to_location)
564
else:
565
raise
566
try:
567
copy_branch(br_from, to_location, revision_id, basis_branch)
568
except bzrlib.errors.NoSuchRevision:
569
rmtree(to_location)
709
710
to_transport = transport.get_transport(to_location)
711
try:
712
to_transport.mkdir('.')
713
except errors.FileExists:
714
raise BzrCommandError('Target directory "%s" already'
715
' exists.' % to_location)
716
except errors.NoSuchFile:
717
raise BzrCommandError('Parent of "%s" does not exist.' %
718
to_location)
719
try:
720
# preserve whatever source format we have.
721
dir = br_from.bzrdir.sprout(to_transport.base,
722
revision_id, basis_dir)
723
branch = dir.open_branch()
724
except errors.NoSuchRevision:
725
to_transport.delete_tree('.')
570
726
msg = "The branch %s has no revision %s." % (from_location, revision[0])
571
727
raise BzrCommandError(msg)
572
except bzrlib.errors.UnlistableBranch:
573
rmtree(to_location)
574
msg = "The branch %s cannot be used as a --basis"
728
except errors.UnlistableBranch:
729
osutils.rmtree(to_location)
730
msg = "The branch %s cannot be used as a --basis" % (basis,)
575
731
raise BzrCommandError(msg)
576
branch = Branch.open(to_location)
577
732
if name:
578
name = StringIO(name)
579
branch.put_controlfile('branch-name', name)
733
branch.control_files.put_utf8('branch-name', name)
580
734
note('Branched %d revision(s).' % branch.revno())
581
735
finally:
582
736
br_from.unlock()
583
737
584
738
739
class cmd_checkout(Command):
740
"""Create a new checkout of an existing branch.
741
742
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
743
the branch found in '.'. This is useful if you have removed the working tree
744
or if it was never created - i.e. if you pushed the branch to its current
745
location using SFTP.
746
747
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
748
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
749
750
To retrieve the branch as of a particular revision, supply the --revision
751
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
752
out of date [so you cannot commit] but it may be useful (i.e. to examine old
753
code.)
754
755
--basis is to speed up checking out from remote branches. When specified, it
756
uses the inventory and file contents from the basis branch in preference to the
757
branch being checked out.
758
"""
759
takes_args = ['branch_location?', 'to_location?']
760
takes_options = ['revision', # , 'basis']
761
Option('lightweight',
762
help="perform a lightweight checkout. Lightweight "
763
"checkouts depend on access to the branch for "
764
"every operation. Normal checkouts can perform "
765
"common operations like diff and status without "
766
"such access, and also support local commits."
767
),
768
]
769
aliases = ['co']
770
771
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
772
lightweight=False):
773
if revision is None:
774
revision = [None]
775
elif len(revision) > 1:
776
raise BzrCommandError(
777
'bzr checkout --revision takes exactly 1 revision value')
778
if branch_location is None:
779
branch_location = osutils.getcwd()
780
to_location = branch_location
781
source = Branch.open(branch_location)
782
if len(revision) == 1 and revision[0] is not None:
783
revision_id = revision[0].in_history(source)[1]
784
else:
785
revision_id = None
786
if to_location is None:
787
to_location = os.path.basename(branch_location.rstrip("/\\"))
788
# if the source and to_location are the same,
789
# and there is no working tree,
790
# then reconstitute a branch
791
if (osutils.abspath(to_location) ==
792
osutils.abspath(branch_location)):
793
try:
794
source.bzrdir.open_workingtree()
795
except errors.NoWorkingTree:
796
source.bzrdir.create_workingtree()
797
return
798
try:
799
os.mkdir(to_location)
800
except OSError, e:
801
if e.errno == errno.EEXIST:
802
raise BzrCommandError('Target directory "%s" already'
803
' exists.' % to_location)
804
if e.errno == errno.ENOENT:
805
raise BzrCommandError('Parent of "%s" does not exist.' %
806
to_location)
807
else:
808
raise
809
old_format = bzrdir.BzrDirFormat.get_default_format()
810
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
811
try:
812
source.create_checkout(to_location, revision_id, lightweight)
813
finally:
814
bzrdir.BzrDirFormat.set_default_format(old_format)
815
816
585
817
class cmd_renames(Command):
586
818
"""Show list of renamed files.
587
819
"""
592
824
593
825
@display_command
594
826
def run(self, dir=u'.'):
827
from bzrlib.tree import find_renames
595
828
tree = WorkingTree.open_containing(dir)[0]
596
old_inv = tree.branch.basis_tree().inventory
829
old_inv = tree.basis_tree().inventory
597
830
new_inv = tree.read_working_inventory()
598
599
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
831
renames = list(find_renames(old_inv, new_inv))
600
832
renames.sort()
601
833
for old_name, new_name in renames:
602
print "%s => %s" % (old_name, new_name)
834
self.outf.write("%s => %s\n" % (old_name, new_name))
835
836
837
class cmd_update(Command):
838
"""Update a tree to have the latest code committed to its branch.
839
840
This will perform a merge into the working tree, and may generate
841
conflicts. If you have any local changes, you will still
842
need to commit them after the update for the update to be complete.
843
844
If you want to discard your local changes, you can just do a
845
'bzr revert' instead of 'bzr commit' after the update.
846
"""
847
takes_args = ['dir?']
848
aliases = ['up']
849
850
def run(self, dir='.'):
851
tree = WorkingTree.open_containing(dir)[0]
852
tree.lock_write()
853
try:
854
existing_pending_merges = tree.get_parent_ids()[1:]
855
last_rev = tree.last_revision()
856
if last_rev == tree.branch.last_revision():
857
# may be up to date, check master too.
858
master = tree.branch.get_master_branch()
859
if master is None or last_rev == master.last_revision():
860
revno = tree.branch.revision_id_to_revno(last_rev)
861
note("Tree is up to date at revision %d." % (revno,))
862
return 0
863
conflicts = tree.update()
864
revno = tree.branch.revision_id_to_revno(tree.last_revision())
865
note('Updated to revision %d.' % (revno,))
866
if tree.get_parent_ids()[1:] != existing_pending_merges:
867
note('Your local commits will now show as pending merges with '
868
"'bzr status', and can be committed with 'bzr commit'.")
869
if conflicts != 0:
870
return 1
871
else:
872
return 0
873
finally:
874
tree.unlock()
603
875
604
876
605
877
class cmd_info(Command):
606
"""Show statistical information about a branch."""
607
takes_args = ['branch?']
608
878
"""Show information about a working tree, branch or repository.
879
880
This command will show all known locations and formats associated to the
881
tree, branch or repository. Statistical information is included with
882
each report.
883
884
Branches and working trees will also report any missing revisions.
885
"""
886
takes_args = ['location?']
887
takes_options = ['verbose']
888
609
889
@display_command
610
def run(self, branch=None):
611
import info
612
b = WorkingTree.open_containing(branch)[0].branch
613
info.show_info(b)
890
def run(self, location=None, verbose=False):
891
from bzrlib.info import show_bzrdir_info
892
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
893
verbose=verbose)
614
894
615
895
616
896
class cmd_remove(Command):
618
898
619
899
This makes bzr stop tracking changes to a versioned file. It does
620
900
not delete the working copy.
901
902
You can specify one or more files, and/or --new. If you specify --new,
903
only 'added' files will be removed. If you specify both, then new files
904
in the specified directories will be removed. If the directories are
905
also new, they will also be removed.
621
906
"""
622
takes_args = ['file+']
623
takes_options = ['verbose']
907
takes_args = ['file*']
908
takes_options = ['verbose', Option('new', help='remove newly-added files')]
624
909
aliases = ['rm']
910
encoding_type = 'replace'
625
911
626
def run(self, file_list, verbose=False):
912
def run(self, file_list, verbose=False, new=False):
627
913
tree, file_list = tree_files(file_list)
628
tree.remove(file_list, verbose=verbose)
914
if new is False:
915
if file_list is None:
916
raise BzrCommandError('Specify one or more files to remove, or'
917
' use --new.')
918
else:
919
added = tree.changes_from(tree.basis_tree(),
920
specific_files=file_list).added
921
file_list = sorted([f[0] for f in added], reverse=True)
922
if len(file_list) == 0:
923
raise BzrCommandError('No matching files.')
924
tree.remove(file_list, verbose=verbose, to_file=self.outf)
629
925
630
926
631
927
class cmd_file_id(Command):
635
931
same through all revisions where the file exists, even when it is
636
932
moved or renamed.
637
933
"""
934
638
935
hidden = True
639
936
takes_args = ['filename']
937
640
938
@display_command
641
939
def run(self, filename):
642
940
tree, relpath = WorkingTree.open_containing(filename)
643
941
i = tree.inventory.path2id(relpath)
644
if i == None:
942
if i is None:
645
943
raise BzrError("%r is not a versioned file" % filename)
646
944
else:
647
print i
945
self.outf.write(i + '\n')
648
946
649
947
650
948
class cmd_file_path(Command):
651
949
"""Print path of file_ids to a file or directory.
652
950
653
951
This prints one line for each directory down to the target,
654
starting at the branch root."""
952
starting at the branch root.
953
"""
954
655
955
hidden = True
656
956
takes_args = ['filename']
957
657
958
@display_command
658
959
def run(self, filename):
659
960
tree, relpath = WorkingTree.open_containing(filename)
660
961
inv = tree.inventory
661
962
fid = inv.path2id(relpath)
662
if fid == None:
963
if fid is None:
663
964
raise BzrError("%r is not a versioned file" % filename)
664
965
for fip in inv.get_idpath(fid):
665
print fip
966
self.outf.write(fip + '\n')
967
968
969
class cmd_reconcile(Command):
970
"""Reconcile bzr metadata in a branch.
971
972
This can correct data mismatches that may have been caused by
973
previous ghost operations or bzr upgrades. You should only
974
need to run this command if 'bzr check' or a bzr developer
975
advises you to run it.
976
977
If a second branch is provided, cross-branch reconciliation is
978
also attempted, which will check that data like the tree root
979
id which was not present in very early bzr versions is represented
980
correctly in both branches.
981
982
At the same time it is run it may recompress data resulting in
983
a potential saving in disk space or performance gain.
984
985
The branch *MUST* be on a listable system such as local disk or sftp.
986
"""
987
takes_args = ['branch?']
988
989
def run(self, branch="."):
990
from bzrlib.reconcile import reconcile
991
dir = bzrdir.BzrDir.open(branch)
992
reconcile(dir)
666
993
667
994
668
995
class cmd_revision_history(Command):
669
"""Display list of revision ids on this branch."""
996
"""Display the list of revision ids on a branch."""
997
takes_args = ['location?']
998
670
999
hidden = True
1000
671
1001
@display_command
672
def run(self):
673
branch = WorkingTree.open_containing(u'.')[0].branch
674
for patchid in branch.revision_history():
675
print patchid
1002
def run(self, location="."):
1003
branch = Branch.open_containing(location)[0]
1004
for revid in branch.revision_history():
1005
self.outf.write(revid)
1006
self.outf.write('\n')
676
1007
677
1008
678
1009
class cmd_ancestry(Command):
679
1010
"""List all revisions merged into this branch."""
1011
takes_args = ['location?']
1012
680
1013
hidden = True
1014
681
1015
@display_command
682
def run(self):
683
tree = WorkingTree.open_containing(u'.')[0]
684
b = tree.branch
685
# FIXME. should be tree.last_revision
686
for revision_id in b.get_ancestry(b.last_revision()):
687
print revision_id
1016
def run(self, location="."):
1017
try:
1018
wt = WorkingTree.open_containing(location)[0]
1019
except errors.NoWorkingTree:
1020
b = Branch.open(location)
1021
last_revision = b.last_revision()
1022
else:
1023
b = wt.branch
1024
last_revision = wt.last_revision()
1025
1026
revision_ids = b.repository.get_ancestry(last_revision)
1027
assert revision_ids[0] is None
1028
revision_ids.pop(0)
1029
for revision_id in revision_ids:
1030
self.outf.write(revision_id + '\n')
688
1031
689
1032
690
1033
class cmd_init(Command):
693
1036
Use this to create an empty branch, or before importing an
694
1037
existing project.
695
1038
1039
If there is a repository in a parent directory of the location, then
1040
the history of the branch will be stored in the repository. Otherwise
1041
init creates a standalone branch which carries its own history in
1042
.bzr.
1043
1044
If there is already a branch at the location but it has no working tree,
1045
the tree can be populated with 'bzr checkout'.
1046
696
1047
Recipe for importing a tree of files:
697
1048
cd ~/project
698
1049
bzr init
701
1052
bzr commit -m 'imported project'
702
1053
"""
703
1054
takes_args = ['location?']
704
def run(self, location=None):
705
from bzrlib.branch import Branch
1055
takes_options = [
1056
Option('format',
1057
help='Specify a format for this branch. Current'
1058
' formats are: default, knit, metaweave and'
1059
' weave. Default is knit; metaweave and'
1060
' weave are deprecated',
1061
type=get_format_type),
1062
]
1063
def run(self, location=None, format=None):
1064
if format is None:
1065
format = get_format_type('default')
706
1066
if location is None:
707
1067
location = u'.'
1068
1069
to_transport = transport.get_transport(location)
1070
1071
# The path has to exist to initialize a
1072
# branch inside of it.
1073
# Just using os.mkdir, since I don't
1074
# believe that we want to create a bunch of
1075
# locations if the user supplies an extended path
1076
# TODO: create-prefix
1077
try:
1078
to_transport.mkdir('.')
1079
except errors.FileExists:
1080
pass
1081
1082
try:
1083
existing_bzrdir = bzrdir.BzrDir.open(location)
1084
except NotBranchError:
1085
# really a NotBzrDir error...
1086
bzrdir.BzrDir.create_branch_convenience(location, format=format)
708
1087
else:
709
# The path has to exist to initialize a
710
# branch inside of it.
711
# Just using os.mkdir, since I don't
712
# believe that we want to create a bunch of
713
# locations if the user supplies an extended path
714
if not os.path.exists(location):
715
os.mkdir(location)
716
Branch.initialize(location)
1088
if existing_bzrdir.has_branch():
1089
if (isinstance(to_transport, LocalTransport)
1090
and not existing_bzrdir.has_workingtree()):
1091
raise errors.BranchExistsWithoutWorkingTree(location)
1092
raise errors.AlreadyBranchError(location)
1093
else:
1094
existing_bzrdir.create_branch()
1095
existing_bzrdir.create_workingtree()
1096
1097
1098
class cmd_init_repository(Command):
1099
"""Create a shared repository to hold branches.
1100
1101
New branches created under the repository directory will store their revisions
1102
in the repository, not in the branch directory, if the branch format supports
1103
shared storage.
1104
1105
example:
1106
bzr init-repo repo
1107
bzr init repo/trunk
1108
bzr checkout --lightweight repo/trunk trunk-checkout
1109
cd trunk-checkout
1110
(add files here)
1111
"""
1112
takes_args = ["location"]
1113
takes_options = [Option('format',
1114
help='Specify a format for this repository.'
1115
' Current formats are: default, knit,'
1116
' metaweave and weave. Default is knit;'
1117
' metaweave and weave are deprecated',
1118
type=get_format_type),
1119
Option('trees',
1120
help='Allows branches in repository to have'
1121
' a working tree')]
1122
aliases = ["init-repo"]
1123
def run(self, location, format=None, trees=False):
1124
if format is None:
1125
format = get_format_type('default')
1126
1127
if location is None:
1128
location = '.'
1129
1130
to_transport = transport.get_transport(location)
1131
try:
1132
to_transport.mkdir('.')
1133
except errors.FileExists:
1134
pass
1135
1136
newdir = format.initialize_on_transport(to_transport)
1137
repo = newdir.create_repository(shared=True)
1138
repo.set_make_working_trees(trees)
717
1139
718
1140
719
1141
class cmd_diff(Command):
720
"""Show differences in working tree.
1142
"""Show differences in the working tree or between revisions.
721
1143
722
1144
If files are listed, only the changes in those files are listed.
723
1145
Otherwise, all changes for the tree are listed.
724
1146
1147
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1148
produces patches suitable for "patch -p1".
1149
725
1150
examples:
726
1151
bzr diff
1152
Shows the difference in the working tree versus the last commit
727
1153
bzr diff -r1
1154
Difference between the working tree and revision 1
728
1155
bzr diff -r1..2
1156
Difference between revision 2 and revision 1
1157
bzr diff --diff-prefix old/:new/
1158
Same as 'bzr diff' but prefix paths with old/ and new/
1159
bzr diff bzr.mine bzr.dev
1160
Show the differences between the two working trees
1161
bzr diff foo.c
1162
Show just the differences for 'foo.c'
729
1163
"""
730
# TODO: Allow diff across branches.
731
1164
# TODO: Option to use external diff command; could be GNU diff, wdiff,
732
1165
# or a graphical diff.
733
1166
734
1167
# TODO: Python difflib is not exactly the same as unidiff; should
735
1168
# either fix it up or prefer to use an external diff.
736
1169
737
# TODO: If a directory is given, diff everything under that.
738
739
1170
# TODO: Selected-file diff is inefficient and doesn't show you
740
1171
# deleted files.
741
1172
742
1173
# TODO: This probably handles non-Unix newlines poorly.
743
1174
744
1175
takes_args = ['file*']
745
takes_options = ['revision', 'diff-options']
1176
takes_options = ['revision', 'diff-options', 'prefix']
746
1177
aliases = ['di', 'dif']
1178
encoding_type = 'exact'
747
1179
748
1180
@display_command
749
def run(self, revision=None, file_list=None, diff_options=None):
750
from bzrlib.diff import show_diff
1181
def run(self, revision=None, file_list=None, diff_options=None,
1182
prefix=None):
1183
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1184
1185
if (prefix is None) or (prefix == '0'):
1186
# diff -p0 format
1187
old_label = ''
1188
new_label = ''
1189
elif prefix == '1':
1190
old_label = 'old/'
1191
new_label = 'new/'
1192
else:
1193
if not ':' in prefix:
1194
raise BzrError("--diff-prefix expects two values separated by a colon")
1195
old_label, new_label = prefix.split(":")
1196
751
1197
try:
752
tree, file_list = internal_tree_files(file_list)
1198
tree1, file_list = internal_tree_files(file_list)
1199
tree2 = None
753
1200
b = None
754
1201
b2 = None
755
1202
except FileInWrongBranch:
756
1203
if len(file_list) != 2:
757
1204
raise BzrCommandError("Files are in different branches")
758
1205
759
b, file1 = Branch.open_containing(file_list[0])
760
b2, file2 = Branch.open_containing(file_list[1])
1206
tree1, file1 = WorkingTree.open_containing(file_list[0])
1207
tree2, file2 = WorkingTree.open_containing(file_list[1])
761
1208
if file1 != "" or file2 != "":
762
1209
# FIXME diff those two files. rbc 20051123
763
1210
raise BzrCommandError("Files are in different branches")
764
1211
file_list = None
1212
except NotBranchError:
1213
if (revision is not None and len(revision) == 2
1214
and not revision[0].needs_branch()
1215
and not revision[1].needs_branch()):
1216
# If both revision specs include a branch, we can
1217
# diff them without needing a local working tree
1218
tree1, tree2 = None, None
1219
else:
1220
raise
765
1221
if revision is not None:
766
if b2 is not None:
1222
if tree2 is not None:
767
1223
raise BzrCommandError("Can't specify -r with two branches")
768
if len(revision) == 1:
769
return show_diff(tree.branch, revision[0], specific_files=file_list,
770
external_diff_options=diff_options)
1224
if (len(revision) == 1) or (revision[1].spec is None):
1225
return diff_cmd_helper(tree1, file_list, diff_options,
1226
revision[0],
1227
old_label=old_label, new_label=new_label)
771
1228
elif len(revision) == 2:
772
return show_diff(tree.branch, revision[0], specific_files=file_list,
773
external_diff_options=diff_options,
774
revision2=revision[1])
1229
return diff_cmd_helper(tree1, file_list, diff_options,
1230
revision[0], revision[1],
1231
old_label=old_label, new_label=new_label)
775
1232
else:
776
1233
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
777
1234
else:
778
if b is not None:
779
return show_diff(b, None, specific_files=file_list,
780
external_diff_options=diff_options, b2=b2)
1235
if tree2 is not None:
1236
return show_diff_trees(tree1, tree2, sys.stdout,
1237
specific_files=file_list,
1238
external_diff_options=diff_options,
1239
old_label=old_label, new_label=new_label)
781
1240
else:
782
return show_diff(tree.branch, None, specific_files=file_list,
783
external_diff_options=diff_options)
1241
return diff_cmd_helper(tree1, file_list, diff_options,
1242
old_label=old_label, new_label=new_label)
784
1243
785
1244
786
1245
class cmd_deleted(Command):
792
1251
# directories with readdir, rather than stating each one. Same
793
1252
# level of effort but possibly much less IO. (Or possibly not,
794
1253
# if the directories are very large...)
1254
takes_options = ['show-ids']
1255
795
1256
@display_command
796
1257
def run(self, show_ids=False):
797
1258
tree = WorkingTree.open_containing(u'.')[0]
798
old = tree.branch.basis_tree()
1259
old = tree.basis_tree()
799
1260
for path, ie in old.inventory.iter_entries():
800
1261
if not tree.has_id(ie.file_id):
1262
self.outf.write(path)
801
1263
if show_ids:
802
print '%-50s %s' % (path, ie.file_id)
803
else:
804
print path
1264
self.outf.write(' ')
1265
self.outf.write(ie.file_id)
1266
self.outf.write('\n')
805
1267
806
1268
807
1269
class cmd_modified(Command):
809
1271
hidden = True
810
1272
@display_command
811
1273
def run(self):
812
from bzrlib.delta import compare_trees
813
814
1274
tree = WorkingTree.open_containing(u'.')[0]
815
td = compare_trees(tree.branch.basis_tree(), tree)
816
1275
td = tree.changes_from(tree.basis_tree())
817
1276
for path, id, kind, text_modified, meta_modified in td.modified:
818
print path
819
1277
self.outf.write(path + '\n')
820
1278
821
1279
822
1280
class cmd_added(Command):
825
1283
@display_command
826
1284
def run(self):
827
1285
wt = WorkingTree.open_containing(u'.')[0]
828
basis_inv = wt.branch.basis_tree().inventory
1286
basis_inv = wt.basis_tree().inventory
829
1287
inv = wt.inventory
830
1288
for file_id in inv:
831
1289
if file_id in basis_inv:
832
1290
continue
833
1291
path = inv.id2path(file_id)
834
if not os.access(b.abspath(path), os.F_OK):
1292
if not os.access(osutils.abspath(path), os.F_OK):
835
1293
continue
836
print path
837
838
1294
self.outf.write(path + '\n')
1295
839
1296
840
1297
class cmd_root(Command):
841
1298
"""Show the tree root directory.
847
1304
def run(self, filename=None):
848
1305
"""Print the branch root."""
849
1306
tree = WorkingTree.open_containing(filename)[0]
850
print tree.basedir
1307
self.outf.write(tree.basedir + '\n')
851
1308
852
1309
853
1310
class cmd_log(Command):
854
"""Show log of this branch.
1311
"""Show log of a branch, file, or directory.
1312
1313
By default show the log of the branch containing the working directory.
855
1314
856
1315
To request a range of logs, you can use the command -r begin..end
857
1316
-r revision requests a specific revision, -r ..end or -r begin.. are
858
1317
also valid.
1318
1319
examples:
1320
bzr log
1321
bzr log foo.c
1322
bzr log -r -10.. http://server/branch
859
1323
"""
860
1324
861
1325
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
862
1326
863
takes_args = ['filename?']
1327
takes_args = ['location?']
864
1328
takes_options = [Option('forward',
865
1329
help='show from oldest to newest'),
866
'timezone', 'verbose',
1330
'timezone',
1331
Option('verbose',
1332
help='show files changed in each revision'),
867
1333
'show-ids', 'revision',
868
Option('line', help='format with one line per revision'),
869
'long',
1334
'log-format',
1335
'line', 'long',
870
1336
Option('message',
871
1337
help='show revisions whose message matches this regexp',
872
1338
type=str),
873
Option('short', help='use moderately short format'),
1339
'short',
874
1340
]
1341
encoding_type = 'replace'
1342
875
1343
@display_command
876
def run(self, filename=None, timezone='original',
1344
def run(self, location=None, timezone='original',
877
1345
verbose=False,
878
1346
show_ids=False,
879
1347
forward=False,
880
1348
revision=None,
1349
log_format=None,
881
1350
message=None,
882
1351
long=False,
883
1352
short=False,
884
1353
line=False):
885
1354
from bzrlib.log import log_formatter, show_log
886
import codecs
887
1355
assert message is None or isinstance(message, basestring), \
888
1356
"invalid message argument %r" % message
889
1357
direction = (forward and 'forward') or 'reverse'
890
1358
891
if filename:
892
# might be a tree:
893
tree = None
894
try:
895
tree, fp = WorkingTree.open_containing(filename)
896
b = tree.branch
897
if fp != '':
898
inv = tree.read_working_inventory()
899
except NotBranchError:
900
pass
901
if tree is None:
902
b, fp = Branch.open_containing(filename)
903
if fp != '':
904
inv = b.get_inventory(b.last_revision())
1359
# log everything
1360
file_id = None
1361
if location:
1362
# find the file id to log:
1363
1364
dir, fp = bzrdir.BzrDir.open_containing(location)
1365
b = dir.open_branch()
905
1366
if fp != '':
1367
try:
1368
# might be a tree:
1369
inv = dir.open_workingtree().inventory
1370
except (errors.NotBranchError, errors.NotLocalUrl):
1371
# either no tree, or is remote.
1372
inv = b.basis_tree().inventory
906
1373
file_id = inv.path2id(fp)
1374
else:
1375
# local dir only
1376
# FIXME ? log the current subdir only RBC 20060203
1377
if revision is not None \
1378
and len(revision) > 0 and revision[0].get_branch():
1379
location = revision[0].get_branch()
907
1380
else:
908
file_id = None # points to branch root
909
else:
910
tree, relpath = WorkingTree.open_containing(u'.')
911
b = tree.branch
912
file_id = None
1381
location = '.'
1382
dir, relpath = bzrdir.BzrDir.open_containing(location)
1383
b = dir.open_branch()
913
1384
914
1385
if revision is None:
915
1386
rev1 = None
917
1388
elif len(revision) == 1:
918
1389
rev1 = rev2 = revision[0].in_history(b).revno
919
1390
elif len(revision) == 2:
920
rev1 = revision[0].in_history(b).revno
921
rev2 = revision[1].in_history(b).revno
1391
if revision[1].get_branch() != revision[0].get_branch():
1392
# b is taken from revision[0].get_branch(), and
1393
# show_log will use its revision_history. Having
1394
# different branches will lead to weird behaviors.
1395
raise BzrCommandError(
1396
"Log doesn't accept two revisions in different branches.")
1397
if revision[0].spec is None:
1398
# missing begin-range means first revision
1399
rev1 = 1
1400
else:
1401
rev1 = revision[0].in_history(b).revno
1402
1403
if revision[1].spec is None:
1404
# missing end-range means last known revision
1405
rev2 = b.revno()
1406
else:
1407
rev2 = revision[1].in_history(b).revno
922
1408
else:
923
1409
raise BzrCommandError('bzr log --revision takes one or two values.')
924
1410
928
1414
if rev1 > rev2:
929
1415
(rev2, rev1) = (rev1, rev2)
930
1416
931
mutter('encoding log as %r', bzrlib.user_encoding)
932
933
# use 'replace' so that we don't abort if trying to write out
934
# in e.g. the default C locale.
935
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
936
937
log_format = 'long'
938
if short:
939
log_format = 'short'
940
if line:
941
log_format = 'line'
1417
if (log_format is None):
1418
default = b.get_config().log_format()
1419
log_format = get_log_format(long=long, short=short, line=line,
1420
default=default)
942
1421
lf = log_formatter(log_format,
943
1422
show_ids=show_ids,
944
to_file=outf,
1423
to_file=self.outf,
945
1424
show_timezone=timezone)
946
1425
947
1426
show_log(b,
954
1433
search=message)
955
1434
956
1435
1436
def get_log_format(long=False, short=False, line=False, default='long'):
1437
log_format = default
1438
if long:
1439
log_format = 'long'
1440
if short:
1441
log_format = 'short'
1442
if line:
1443
log_format = 'line'
1444
return log_format
1445
957
1446
958
1447
class cmd_touching_revisions(Command):
959
1448
"""Return revision-ids which affected a particular file.
960
1449
961
A more user-friendly interface is "bzr log FILE"."""
1450
A more user-friendly interface is "bzr log FILE".
1451
"""
1452
962
1453
hidden = True
963
1454
takes_args = ["filename"]
1455
964
1456
@display_command
965
1457
def run(self, filename):
966
1458
tree, relpath = WorkingTree.open_containing(filename)
967
1459
b = tree.branch
968
1460
inv = tree.read_working_inventory()
969
1461
file_id = inv.path2id(relpath)
970
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
971
print "%6d %s" % (revno, what)
1462
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1463
self.outf.write("%6d %s\n" % (revno, what))
972
1464
973
1465
974
1466
class cmd_ls(Command):
1005
1497
elif relpath:
1006
1498
relpath += '/'
1007
1499
if revision is not None:
1008
tree = tree.branch.revision_tree(
1500
tree = tree.branch.repository.revision_tree(
1009
1501
revision[0].in_history(tree.branch).rev_id)
1502
1010
1503
for fp, fc, kind, fid, entry in tree.list_files():
1011
1504
if fp.startswith(relpath):
1012
1505
fp = fp[len(relpath):]
1016
1509
continue
1017
1510
if verbose:
1018
1511
kindch = entry.kind_character()
1019
print '%-8s %s%s' % (fc, fp, kindch)
1512
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1020
1513
elif null:
1021
sys.stdout.write(fp)
1022
sys.stdout.write('\0')
1023
sys.stdout.flush()
1514
self.outf.write(fp + '\0')
1515
self.outf.flush()
1024
1516
else:
1025
print fp
1517
self.outf.write(fp + '\n')
1026
1518
1027
1519
1028
1520
class cmd_unknowns(Command):
1029
1521
"""List unknown files."""
1030
1522
@display_command
1031
1523
def run(self):
1032
from bzrlib.osutils import quotefn
1033
1524
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1034
print quotefn(f)
1525
self.outf.write(osutils.quotefn(f) + '\n')
1035
1526
1036
1527
1037
1528
class cmd_ignore(Command):
1053
1544
bzr ignore '*.class'
1054
1545
"""
1055
1546
# TODO: Complain if the filename is absolute
1056
takes_args = ['name_pattern']
1547
takes_args = ['name_pattern?']
1548
takes_options = [
1549
Option('old-default-rules',
1550
help='Out the ignore rules bzr < 0.9 always used.')
1551
]
1057
1552
1058
def run(self, name_pattern):
1553
def run(self, name_pattern=None, old_default_rules=None):
1059
1554
from bzrlib.atomicfile import AtomicFile
1060
import os.path
1061
1555
if old_default_rules is not None:
1556
# dump the rules and exit
1557
for pattern in ignores.OLD_DEFAULTS:
1558
print pattern
1559
return
1560
if name_pattern is None:
1561
raise BzrCommandError("ignore requires a NAME_PATTERN")
1062
1562
tree, relpath = WorkingTree.open_containing(u'.')
1063
1563
ifn = tree.abspath('.bzrignore')
1064
1065
1564
if os.path.exists(ifn):
1066
1565
f = open(ifn, 'rt')
1067
1566
try:
1078
1577
igns += '\n'
1079
1578
igns += name_pattern + '\n'
1080
1579
1580
f = AtomicFile(ifn, 'wt')
1081
1581
try:
1082
f = AtomicFile(ifn, 'wt')
1083
1582
f.write(igns.encode('utf-8'))
1084
1583
f.commit()
1085
1584
finally:
1141
1640
1142
1641
Note: export of tree with non-ascii filenames to zip is not supported.
1143
1642
1144
Supported formats Autodetected by extension
1145
----------------- -------------------------
1643
Supported formats Autodetected by extension
1644
----------------- -------------------------
1146
1645
dir -
1147
1646
tar .tar
1148
1647
tbz2 .tar.bz2, .tbz2
1152
1651
takes_args = ['dest']
1153
1652
takes_options = ['revision', 'format', 'root']
1154
1653
def run(self, dest, revision=None, format=None, root=None):
1155
import os.path
1156
1654
from bzrlib.export import export
1157
1655
tree = WorkingTree.open_containing(u'.')[0]
1158
1656
b = tree.branch
1163
1661
if len(revision) != 1:
1164
1662
raise BzrError('bzr export --revision takes exactly 1 argument')
1165
1663
rev_id = revision[0].in_history(b).rev_id
1166
t = b.revision_tree(rev_id)
1664
t = b.repository.revision_tree(rev_id)
1167
1665
try:
1168
1666
export(t, dest, format, root)
1169
1667
except errors.NoSuchExportFormat, e:
1189
1687
1190
1688
if tree is None:
1191
1689
b, relpath = Branch.open_containing(filename)
1690
if revision is not None and revision[0].get_branch() is not None:
1691
b = Branch.open(revision[0].get_branch())
1192
1692
if revision is None:
1193
1693
revision_id = b.last_revision()
1194
1694
else:
1201
1701
hidden = True
1202
1702
@display_command
1203
1703
def run(self):
1204
print bzrlib.osutils.local_time_offset()
1704
print osutils.local_time_offset()
1205
1705
1206
1706
1207
1707
1237
1737
Option('strict',
1238
1738
help="refuse to commit if there are unknown "
1239
1739
"files in the working tree."),
1740
Option('local',
1741
help="perform a local only commit in a bound "
1742
"branch. Such commits are not pushed to "
1743
"the master branch until a normal commit "
1744
"is performed."
1745
),
1240
1746
]
1241
1747
aliases = ['ci', 'checkin']
1242
1748
1243
1749
def run(self, message=None, file=None, verbose=True, selected_list=None,
1244
unchanged=False, strict=False):
1750
unchanged=False, strict=False, local=False):
1751
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1245
1752
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1246
1753
StrictCommitFailed)
1247
1754
from bzrlib.msgeditor import edit_commit_message, \
1248
1755
make_commit_message_template
1249
from bzrlib.status import show_status
1250
1756
from tempfile import TemporaryFile
1251
import codecs
1252
1757
1253
1758
# TODO: Need a blackbox test for invoking the external editor; may be
1254
1759
# slightly problematic to run this cross-platform.
1259
1764
# TODO: if the commit *does* happen to fail, then save the commit
1260
1765
# message to a temporary file where it can be recovered
1261
1766
tree, selected_list = tree_files(selected_list)
1767
if selected_list == ['']:
1768
# workaround - commit of root of tree should be exactly the same
1769
# as just default commit in that tree, and succeed even though
1770
# selected-file merge commit is not done yet
1771
selected_list = []
1772
1773
if local and not tree.branch.get_bound_location():
1774
raise errors.LocalRequiresBoundBranch()
1262
1775
if message is None and not file:
1263
1776
template = make_commit_message_template(tree, selected_list)
1264
1777
message = edit_commit_message(template)
1269
1782
raise BzrCommandError("please specify either --message or --file")
1270
1783
1271
1784
if file:
1272
import codecs
1273
1785
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1274
1786
1275
1787
if message == "":
1276
raise BzrCommandError("empty commit message specified")
1277
1788
raise BzrCommandError("empty commit message specified")
1789
1790
if verbose:
1791
reporter = ReportCommitToLog()
1792
else:
1793
reporter = NullCommitReporter()
1794
1278
1795
try:
1279
1796
tree.commit(message, specific_files=selected_list,
1280
allow_pointless=unchanged, strict=strict)
1797
allow_pointless=unchanged, strict=strict, local=local,
1798
reporter=reporter)
1281
1799
except PointlessCommit:
1282
1800
# FIXME: This should really happen before the file is read in;
1283
1801
# perhaps prepare the commit; get the message; then actually commit
1284
raise BzrCommandError("no changes to commit",
1285
["use --unchanged to commit anyhow"])
1802
raise BzrCommandError("no changes to commit."
1803
" use --unchanged to commit anyhow")
1286
1804
except ConflictsInTree:
1287
1805
raise BzrCommandError("Conflicts detected in working tree. "
1288
1806
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1289
1807
except StrictCommitFailed:
1290
1808
raise BzrCommandError("Commit refused because there are unknown "
1291
1809
"files in the working tree.")
1292
note('Committed revision %d.' % (tree.branch.revno(),))
1293
1810
except errors.BoundBranchOutOfDate, e:
1811
raise BzrCommandError(str(e) + "\n"
1812
'To commit to master branch, run update and then commit.\n'
1813
'You can also pass --local to commit to continue working '
1814
'disconnected.')
1294
1815
1295
1816
class cmd_check(Command):
1296
1817
"""Validate consistency of branch history.
1328
1849
1329
1850
if c.needs_write:
1330
1851
c.write()
1331
1332
1852
1333
1853
1334
1854
class cmd_upgrade(Command):
1335
1855
"""Upgrade branch storage to current format.
1336
1856
1337
1857
The check command or bzr developers may sometimes advise you to run
1338
this command.
1339
1340
This version of this command upgrades from the full-text storage
1341
used by bzr 0.0.8 and earlier to the weave format (v5).
1858
this command. When the default format has changed you may also be warned
1859
during other operations to upgrade.
1342
1860
"""
1343
takes_args = ['dir?']
1344
1345
def run(self, dir=u'.'):
1861
takes_args = ['url?']
1862
takes_options = [
1863
Option('format',
1864
help='Upgrade to a specific format. Current formats'
1865
' are: default, knit, metaweave and weave.'
1866
' Default is knit; metaweave and weave are'
1867
' deprecated',
1868
type=get_format_type),
1869
]
1870
1871
1872
def run(self, url='.', format=None):
1346
1873
from bzrlib.upgrade import upgrade
1347
upgrade(dir)
1874
if format is None:
1875
format = get_format_type('default')
1876
upgrade(url, format)
1348
1877
1349
1878
1350
1879
class cmd_whoami(Command):
1351
"""Show bzr user id."""
1352
takes_options = ['email']
1880
"""Show or set bzr user id.
1881
1882
examples:
1883
bzr whoami --email
1884
bzr whoami 'Frank Chu <fchu@example.com>'
1885
"""
1886
takes_options = [ Option('email',
1887
help='display email address only'),
1888
Option('branch',
1889
help='set identity for the current branch instead of '
1890
'globally'),
1891
]
1892
takes_args = ['name?']
1893
encoding_type = 'replace'
1353
1894
1354
1895
@display_command
1355
def run(self, email=False):
1896
def run(self, email=False, branch=False, name=None):
1897
if name is None:
1898
# use branch if we're inside one; otherwise global config
1899
try:
1900
c = Branch.open_containing('.')[0].get_config()
1901
except NotBranchError:
1902
c = config.GlobalConfig()
1903
if email:
1904
self.outf.write(c.user_email() + '\n')
1905
else:
1906
self.outf.write(c.username() + '\n')
1907
return
1908
1909
# display a warning if an email address isn't included in the given name.
1356
1910
try:
1357
b = WorkingTree.open_containing(u'.')[0].branch
1358
config = bzrlib.config.BranchConfig(b)
1359
except NotBranchError:
1360
config = bzrlib.config.GlobalConfig()
1911
config.extract_email_address(name)
1912
except BzrError, e:
1913
warning('"%s" does not seem to contain an email address. '
1914
'This is allowed, but not recommended.', name)
1361
1915
1362
if email:
1363
print config.user_email()
1916
# use global config unless --branch given
1917
if branch:
1918
c = Branch.open_containing('.')[0].get_config()
1364
1919
else:
1365
print config.username()
1920
c = config.GlobalConfig()
1921
c.set_user_option('email', name)
1922
1366
1923
1367
1924
class cmd_nick(Command):
1368
"""\
1369
Print or set the branch nickname.
1925
"""Print or set the branch nickname.
1926
1370
1927
If unset, the tree root directory name is used as the nickname
1371
1928
To print the current nickname, execute with no argument.
1372
1929
"""
1382
1939
def printme(self, branch):
1383
1940
print branch.nick
1384
1941
1942
1385
1943
class cmd_selftest(Command):
1386
1944
"""Run internal test suite.
1387
1945
1392
1950
1393
1951
If arguments are given, they are regular expressions that say
1394
1952
which tests should run.
1953
1954
If the global option '--no-plugins' is given, plugins are not loaded
1955
before running the selftests. This has two effects: features provided or
1956
modified by plugins will not be tested, and tests provided by plugins will
1957
not be run.
1958
1959
examples:
1960
bzr selftest ignore
1961
bzr --no-plugins selftest -v
1395
1962
"""
1396
1963
# TODO: --list should give a list of all available tests
1964
1965
# NB: this is used from the class without creating an instance, which is
1966
# why it does not have a self parameter.
1967
def get_transport_type(typestring):
1968
"""Parse and return a transport specifier."""
1969
if typestring == "sftp":
1970
from bzrlib.transport.sftp import SFTPAbsoluteServer
1971
return SFTPAbsoluteServer
1972
if typestring == "memory":
1973
from bzrlib.transport.memory import MemoryServer
1974
return MemoryServer
1975
if typestring == "fakenfs":
1976
from bzrlib.transport.fakenfs import FakeNFSServer
1977
return FakeNFSServer
1978
msg = "No known transport type %s. Supported types are: sftp\n" %\
1979
(typestring)
1980
raise BzrCommandError(msg)
1981
1397
1982
hidden = True
1398
1983
takes_args = ['testspecs*']
1399
takes_options = ['verbose',
1984
takes_options = ['verbose',
1400
1985
Option('one', help='stop when one test fails'),
1401
1986
Option('keep-output',
1402
help='keep output directories when tests fail')
1403
]
1987
help='keep output directories when tests fail'),
1988
Option('transport',
1989
help='Use a different transport by default '
1990
'throughout the test suite.',
1991
type=get_transport_type),
1992
Option('benchmark', help='run the bzr bencharks.'),
1993
Option('lsprof-timed',
1994
help='generate lsprof output for benchmarked'
1995
' sections of code.'),
1996
Option('cache-dir', type=str,
1997
help='a directory to cache intermediate'
1998
' benchmark steps'),
1999
]
1404
2000
1405
def run(self, testspecs_list=None, verbose=False, one=False,
1406
keep_output=False):
2001
def run(self, testspecs_list=None, verbose=None, one=False,
2002
keep_output=False, transport=None, benchmark=None,
2003
lsprof_timed=None, cache_dir=None):
1407
2004
import bzrlib.ui
1408
2005
from bzrlib.tests import selftest
2006
import bzrlib.benchmarks as benchmarks
2007
from bzrlib.benchmarks import tree_creator
2008
2009
if cache_dir is not None:
2010
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
1409
2011
# we don't want progress meters from the tests to go to the
1410
2012
# real output; and we don't want log messages cluttering up
1411
2013
# the real logs.
1412
save_ui = bzrlib.ui.ui_factory
1413
bzrlib.trace.info('running tests...')
2014
save_ui = ui.ui_factory
2015
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
2016
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2017
print
2018
info('running tests...')
1414
2019
try:
1415
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
2020
ui.ui_factory = ui.SilentUIFactory()
1416
2021
if testspecs_list is not None:
1417
2022
pattern = '|'.join(testspecs_list)
1418
2023
else:
1419
2024
pattern = ".*"
1420
result = selftest(verbose=verbose,
1421
pattern=pattern,
1422
stop_on_failure=one,
1423
keep_output=keep_output)
2025
if benchmark:
2026
test_suite_factory = benchmarks.test_suite
2027
if verbose is None:
2028
verbose = True
2029
# TODO: should possibly lock the history file...
2030
benchfile = open(".perf_history", "at")
2031
else:
2032
test_suite_factory = None
2033
if verbose is None:
2034
verbose = False
2035
benchfile = None
2036
try:
2037
result = selftest(verbose=verbose,
2038
pattern=pattern,
2039
stop_on_failure=one,
2040
keep_output=keep_output,
2041
transport=transport,
2042
test_suite_factory=test_suite_factory,
2043
lsprof_timed=lsprof_timed,
2044
bench_history=benchfile)
2045
finally:
2046
if benchfile is not None:
2047
benchfile.close()
1424
2048
if result:
1425
bzrlib.trace.info('tests passed')
2049
info('tests passed')
1426
2050
else:
1427
bzrlib.trace.info('tests failed')
2051
info('tests failed')
1428
2052
return int(not result)
1429
2053
finally:
1430
bzrlib.ui.ui_factory = save_ui
1431
1432
1433
def show_version():
1434
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1435
# is bzrlib itself in a branch?
1436
bzrrev = bzrlib.get_bzr_revision()
1437
if bzrrev:
1438
print " (bzr checkout, revision %d {%s})" % bzrrev
1439
print bzrlib.__copyright__
1440
print "http://bazaar-ng.org/"
1441
print
1442
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1443
print "you may use, modify and redistribute it under the terms of the GNU"
1444
print "General Public License version 2 or later."
2054
ui.ui_factory = save_ui
1445
2055
1446
2056
1447
2057
class cmd_version(Command):
1448
2058
"""Show version of bzr."""
2059
1449
2060
@display_command
1450
2061
def run(self):
2062
from bzrlib.version import show_version
1451
2063
show_version()
1452
2064
2065
1453
2066
class cmd_rocks(Command):
1454
2067
"""Statement of optimism."""
2068
1455
2069
hidden = True
2070
1456
2071
@display_command
1457
2072
def run(self):
1458
2073
print "it sure does!"
1459
2074
1460
2075
1461
2076
class cmd_find_merge_base(Command):
1462
"""Find and print a base revision for merging two branches.
1463
"""
2077
"""Find and print a base revision for merging two branches."""
1464
2078
# TODO: Options to specify revisions on either side, as if
1465
2079
# merging only part of the history.
1466
2080
takes_args = ['branch', 'other']
1479
2093
last1 = branch1.last_revision()
1480
2094
last2 = branch2.last_revision()
1481
2095
1482
source = MultipleRevisionSources(branch1, branch2)
2096
source = MultipleRevisionSources(branch1.repository,
2097
branch2.repository)
1483
2098
1484
2099
base_rev_id = common_ancestor(last1, last2, source)
1485
2100
1486
2101
print 'merge base is revision %s' % base_rev_id
1487
1488
return
1489
1490
if base_revno is None:
1491
raise bzrlib.errors.UnrelatedBranches()
1492
1493
print ' r%-6d in %s' % (base_revno, branch)
1494
1495
other_revno = branch2.revision_id_to_revno(base_revid)
1496
1497
print ' r%-6d in %s' % (other_revno, other)
1498
1499
2102
1500
2103
1501
2104
class cmd_merge(Command):
1502
2105
"""Perform a three-way merge.
1503
2106
1504
The branch is the branch you will merge from. By default, it will
1505
merge the latest revision. If you specify a revision, that
1506
revision will be merged. If you specify two revisions, the first
1507
will be used as a BASE, and the second one as OTHER. Revision
1508
numbers are always relative to the specified branch.
2107
The branch is the branch you will merge from. By default, it will merge
2108
the latest revision. If you specify a revision, that revision will be
2109
merged. If you specify two revisions, the first will be used as a BASE,
2110
and the second one as OTHER. Revision numbers are always relative to the
2111
specified branch.
1509
2112
1510
By default bzr will try to merge in all new work from the other
2113
By default, bzr will try to merge in all new work from the other
1511
2114
branch, automatically determining an appropriate base. If this
1512
2115
fails, you may need to give an explicit base.
1513
2116
2117
Merge will do its best to combine the changes in two branches, but there
2118
are some kinds of problems only a human can fix. When it encounters those,
2119
it will mark a conflict. A conflict means that you need to fix something,
2120
before you should commit.
2121
2122
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2123
2124
If there is no default branch set, the first merge will set it. After
2125
that, you can omit the branch to use the default. To change the
2126
default, use --remember. The value will only be saved if the remote
2127
location can be accessed.
2128
1514
2129
Examples:
1515
2130
1516
2131
To merge the latest revision from bzr.dev
1524
2139
1525
2140
merge refuses to run if there are any uncommitted changes, unless
1526
2141
--force is given.
2142
2143
The following merge types are available:
1527
2144
"""
1528
2145
takes_args = ['branch?']
1529
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
2146
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
1530
2147
Option('show-base', help="Show base revision text in "
1531
"conflicts")]
2148
"conflicts"),
2149
Option('uncommitted', help='Apply uncommitted changes'
2150
' from a working copy, instead of branch changes')]
2151
2152
def help(self):
2153
from merge import merge_type_help
2154
from inspect import getdoc
2155
return getdoc(self) + '\n' + merge_type_help()
1532
2156
1533
2157
def run(self, branch=None, revision=None, force=False, merge_type=None,
1534
show_base=False, reprocess=False):
1535
from bzrlib.merge import merge
1536
from bzrlib.merge_core import ApplyMerge3
2158
show_base=False, reprocess=False, remember=False,
2159
uncommitted=False):
1537
2160
if merge_type is None:
1538
merge_type = ApplyMerge3
1539
if branch is None:
1540
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1541
if branch is None:
1542
raise BzrCommandError("No merge location known or specified.")
2161
merge_type = Merge3Merger
2162
2163
tree = WorkingTree.open_containing(u'.')[0]
2164
2165
if branch is not None:
2166
try:
2167
reader = bundle.read_bundle_from_url(branch)
2168
except NotABundle:
2169
pass # Continue on considering this url a Branch
1543
2170
else:
1544
print "Using saved location: %s" % branch
2171
conflicts = merge_bundle(reader, tree, not force, merge_type,
2172
reprocess, show_base)
2173
if conflicts == 0:
2174
return 0
2175
else:
2176
return 1
2177
2178
if revision is None \
2179
or len(revision) < 1 or revision[0].needs_branch():
2180
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2181
1545
2182
if revision is None or len(revision) < 1:
1546
base = [None, None]
1547
other = [branch, -1]
2183
if uncommitted:
2184
base = [branch, -1]
2185
other = [branch, None]
2186
else:
2187
base = [None, None]
2188
other = [branch, -1]
2189
other_branch, path = Branch.open_containing(branch)
1548
2190
else:
2191
if uncommitted:
2192
raise BzrCommandError('Cannot use --uncommitted and --revision'
2193
' at the same time.')
2194
branch = revision[0].get_branch() or branch
1549
2195
if len(revision) == 1:
1550
2196
base = [None, None]
1551
other_branch = Branch.open_containing(branch)[0]
2197
other_branch, path = Branch.open_containing(branch)
1552
2198
revno = revision[0].in_history(other_branch).revno
1553
2199
other = [branch, revno]
1554
2200
else:
1555
2201
assert len(revision) == 2
1556
2202
if None in revision:
1557
2203
raise BzrCommandError(
1558
"Merge doesn't permit that revision specifier.")
1559
b = Branch.open_containing(branch)[0]
1560
1561
base = [branch, revision[0].in_history(b).revno]
1562
other = [branch, revision[1].in_history(b).revno]
1563
2204
"Merge doesn't permit empty revision specifier.")
2205
base_branch, path = Branch.open_containing(branch)
2206
branch1 = revision[1].get_branch() or branch
2207
other_branch, path1 = Branch.open_containing(branch1)
2208
if revision[0].get_branch() is not None:
2209
# then path was obtained from it, and is None.
2210
path = path1
2211
2212
base = [branch, revision[0].in_history(base_branch).revno]
2213
other = [branch1, revision[1].in_history(other_branch).revno]
2214
2215
if tree.branch.get_parent() is None or remember:
2216
tree.branch.set_parent(other_branch.base)
2217
2218
if path != "":
2219
interesting_files = [path]
2220
else:
2221
interesting_files = None
2222
pb = ui.ui_factory.nested_progress_bar()
1564
2223
try:
1565
conflict_count = merge(other, base, check_clean=(not force),
1566
merge_type=merge_type, reprocess=reprocess,
1567
show_base=show_base)
2224
try:
2225
conflict_count = merge(other, base, check_clean=(not force),
2226
merge_type=merge_type,
2227
reprocess=reprocess,
2228
show_base=show_base,
2229
pb=pb, file_list=interesting_files)
2230
finally:
2231
pb.finished()
1568
2232
if conflict_count != 0:
1569
2233
return 1
1570
2234
else:
1571
2235
return 0
1572
except bzrlib.errors.AmbiguousBase, e:
2236
except errors.AmbiguousBase, e:
1573
2237
m = ("sorry, bzr can't determine the right merge base yet\n"
1574
2238
"candidates are:\n "
1575
2239
+ "\n ".join(e.bases)
1578
2242
"and (if you want) report this to the bzr developers\n")
1579
2243
log_error(m)
1580
2244
2245
# TODO: move up to common parent; this isn't merge-specific anymore.
2246
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2247
"""Use tree.branch's parent if none was supplied.
2248
2249
Report if the remembered location was used.
2250
"""
2251
if supplied_location is not None:
2252
return supplied_location
2253
stored_location = tree.branch.get_parent()
2254
mutter("%s", stored_location)
2255
if stored_location is None:
2256
raise BzrCommandError("No location specified or remembered")
2257
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2258
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2259
return stored_location
2260
1581
2261
1582
2262
class cmd_remerge(Command):
1583
2263
"""Redo a merge.
1584
"""
2264
2265
Use this if you want to try a different merge technique while resolving
2266
conflicts. Some merge techniques are better than others, and remerge
2267
lets you try different ones on different files.
2268
2269
The options for remerge have the same meaning and defaults as the ones for
2270
merge. The difference is that remerge can (only) be run when there is a
2271
pending merge, and it lets you specify particular files.
2272
2273
Examples:
2274
$ bzr remerge --show-base
2275
Re-do the merge of all conflicted files, and show the base text in
2276
conflict regions, in addition to the usual THIS and OTHER texts.
2277
2278
$ bzr remerge --merge-type weave --reprocess foobar
2279
Re-do the merge of "foobar", using the weave merge algorithm, with
2280
additional processing to reduce the size of conflict regions.
2281
2282
The following merge types are available:"""
1585
2283
takes_args = ['file*']
1586
2284
takes_options = ['merge-type', 'reprocess',
1587
2285
Option('show-base', help="Show base revision text in "
1588
2286
"conflicts")]
1589
2287
2288
def help(self):
2289
from merge import merge_type_help
2290
from inspect import getdoc
2291
return getdoc(self) + '\n' + merge_type_help()
2292
1590
2293
def run(self, file_list=None, merge_type=None, show_base=False,
1591
2294
reprocess=False):
1592
2295
from bzrlib.merge import merge_inner, transform_tree
1593
from bzrlib.merge_core import ApplyMerge3
1594
2296
if merge_type is None:
1595
merge_type = ApplyMerge3
2297
merge_type = Merge3Merger
1596
2298
tree, file_list = tree_files(file_list)
1597
2299
tree.lock_write()
1598
2300
try:
1599
pending_merges = tree.pending_merges()
1600
if len(pending_merges) != 1:
2301
parents = tree.get_parent_ids()
2302
if len(parents) != 2:
1601
2303
raise BzrCommandError("Sorry, remerge only works after normal"
1602
+ " merges. Not cherrypicking or"
1603
+ "multi-merges.")
1604
base_revision = common_ancestor(tree.branch.last_revision(),
1605
pending_merges[0], tree.branch)
1606
base_tree = tree.branch.revision_tree(base_revision)
1607
other_tree = tree.branch.revision_tree(pending_merges[0])
2304
" merges. Not cherrypicking or"
2305
" multi-merges.")
2306
repository = tree.branch.repository
2307
base_revision = common_ancestor(parents[0],
2308
parents[1], repository)
2309
base_tree = repository.revision_tree(base_revision)
2310
other_tree = repository.revision_tree(parents[1])
1608
2311
interesting_ids = None
2312
new_conflicts = []
2313
conflicts = tree.conflicts()
1609
2314
if file_list is not None:
1610
2315
interesting_ids = set()
1611
2316
for filename in file_list:
1612
2317
file_id = tree.path2id(filename)
2318
if file_id is None:
2319
raise NotVersionedError(filename)
1613
2320
interesting_ids.add(file_id)
1614
2321
if tree.kind(file_id) != "directory":
1615
2322
continue
1616
2323
1617
2324
for name, ie in tree.inventory.iter_entries(file_id):
1618
2325
interesting_ids.add(ie.file_id)
1619
transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
2326
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2327
transform_tree(tree, tree.basis_tree(), interesting_ids)
2328
tree.set_conflicts(ConflictList(new_conflicts))
1620
2329
if file_list is None:
1621
2330
restore_files = list(tree.iter_conflicts())
1622
2331
else:
1626
2335
restore(tree.abspath(filename))
1627
2336
except NotConflicted:
1628
2337
pass
1629
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1630
interesting_ids = interesting_ids,
1631
other_rev_id=pending_merges[0],
1632
merge_type=merge_type,
1633
show_base=show_base,
1634
reprocess=reprocess)
2338
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2339
this_tree=tree,
2340
interesting_ids=interesting_ids,
2341
other_rev_id=parents[1],
2342
merge_type=merge_type,
2343
show_base=show_base,
2344
reprocess=reprocess)
1635
2345
finally:
1636
2346
tree.unlock()
1637
2347
if conflicts > 0:
1640
2350
return 0
1641
2351
1642
2352
class cmd_revert(Command):
1643
"""Reverse all changes since the last commit.
1644
1645
Only versioned files are affected. Specify filenames to revert only
1646
those files. By default, any files that are changed will be backed up
1647
first. Backup files have a '~' appended to their name.
2353
"""Revert files to a previous revision.
2354
2355
Giving a list of files will revert only those files. Otherwise, all files
2356
will be reverted. If the revision is not specified with '--revision', the
2357
last committed revision is used.
2358
2359
To remove only some changes, without reverting to a prior version, use
2360
merge instead. For example, "merge . --r-2..-3" will remove the changes
2361
introduced by -2, without affecting the changes introduced by -1. Or
2362
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2363
2364
By default, any files that have been manually changed will be backed up
2365
first. (Files changed only by merge are not backed up.) Backup files have
2366
'.~#~' appended to their name, where # is a number.
2367
2368
When you provide files, you can use their current pathname or the pathname
2369
from the target revision. So you can use revert to "undelete" a file by
2370
name. If you name a directory, all the contents of that directory will be
2371
reverted.
1648
2372
"""
1649
2373
takes_options = ['revision', 'no-backup']
1650
2374
takes_args = ['file*']
1651
2375
aliases = ['merge-revert']
1652
2376
1653
2377
def run(self, revision=None, no_backup=False, file_list=None):
1654
from bzrlib.merge import merge_inner
1655
2378
from bzrlib.commands import parse_spec
1656
2379
if file_list is not None:
1657
2380
if len(file_list) == 0:
1658
2381
raise BzrCommandError("No files specified")
1659
2382
else:
1660
2383
file_list = []
2384
2385
tree, file_list = tree_files(file_list)
1661
2386
if revision is None:
1662
revno = -1
1663
tree = WorkingTree.open_containing(u'.')[0]
1664
2387
# FIXME should be tree.last_revision
1665
rev_id = tree.branch.last_revision()
2388
rev_id = tree.last_revision()
1666
2389
elif len(revision) != 1:
1667
2390
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1668
2391
else:
1669
tree, file_list = tree_files(file_list)
1670
2392
rev_id = revision[0].in_history(tree.branch).rev_id
1671
tree.revert(file_list, tree.branch.revision_tree(rev_id),
1672
not no_backup)
2393
pb = ui.ui_factory.nested_progress_bar()
2394
try:
2395
tree.revert(file_list,
2396
tree.branch.repository.revision_tree(rev_id),
2397
not no_backup, pb)
2398
finally:
2399
pb.finished()
1673
2400
1674
2401
1675
2402
class cmd_assert_fail(Command):
1683
2410
"""Show help on a command or other topic.
1684
2411
1685
2412
For a list of all available commands, say 'bzr help commands'."""
1686
takes_options = ['long']
2413
takes_options = [Option('long', 'show help on all commands')]
1687
2414
takes_args = ['topic?']
1688
aliases = ['?']
2415
aliases = ['?', '--help', '-?', '-h']
1689
2416
1690
2417
@display_command
1691
2418
def run(self, topic=None, long=False):
1717
2444
takes_args = ['from_branch', 'to_branch']
1718
2445
def run(self, from_branch, to_branch):
1719
2446
from bzrlib.fetch import Fetcher
1720
from bzrlib.branch import Branch
1721
2447
from_b = Branch.open(from_branch)
1722
2448
to_b = Branch.open(to_branch)
1723
from_b.lock_read()
1724
try:
1725
to_b.lock_write()
1726
try:
1727
Fetcher(to_b, from_b)
1728
finally:
1729
to_b.unlock()
1730
finally:
1731
from_b.unlock()
2449
Fetcher(to_b, from_b)
1732
2450
1733
2451
1734
2452
class cmd_missing(Command):
1735
"""What is missing in this branch relative to other branch.
1736
"""
1737
# TODO: rewrite this in terms of ancestry so that it shows only
1738
# unmerged things
1739
1740
takes_args = ['remote?']
1741
aliases = ['mis', 'miss']
1742
takes_options = ['verbose']
2453
"""Show unmerged/unpulled revisions between two branches.
2454
2455
OTHER_BRANCH may be local or remote."""
2456
takes_args = ['other_branch?']
2457
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2458
Option('mine-only',
2459
'Display changes in the local branch only'),
2460
Option('theirs-only',
2461
'Display changes in the remote branch only'),
2462
'log-format',
2463
'line',
2464
'long',
2465
'short',
2466
'show-ids',
2467
'verbose'
2468
]
2469
encoding_type = 'replace'
1743
2470
1744
2471
@display_command
1745
def run(self, remote=None, verbose=False):
1746
from bzrlib.errors import BzrCommandError
1747
from bzrlib.missing import show_missing
1748
1749
if verbose and is_quiet():
1750
raise BzrCommandError('Cannot pass both quiet and verbose')
1751
1752
tree = WorkingTree.open_containing(u'.')[0]
1753
parent = tree.branch.get_parent()
1754
if remote is None:
1755
if parent is None:
1756
raise BzrCommandError("No missing location known or specified.")
1757
else:
1758
if not is_quiet():
1759
print "Using last location: %s" % parent
1760
remote = parent
1761
elif parent is None:
1762
# We only update parent if it did not exist, missing
1763
# should not change the parent
1764
tree.branch.set_parent(remote)
1765
br_remote = Branch.open_containing(remote)[0]
1766
return show_missing(tree.branch, br_remote, verbose=verbose,
1767
quiet=is_quiet())
2472
def run(self, other_branch=None, reverse=False, mine_only=False,
2473
theirs_only=False, log_format=None, long=False, short=False, line=False,
2474
show_ids=False, verbose=False):
2475
from bzrlib.missing import find_unmerged, iter_log_data
2476
from bzrlib.log import log_formatter
2477
local_branch = Branch.open_containing(u".")[0]
2478
parent = local_branch.get_parent()
2479
if other_branch is None:
2480
other_branch = parent
2481
if other_branch is None:
2482
raise BzrCommandError("No peer location known or specified.")
2483
print "Using last location: " + local_branch.get_parent()
2484
remote_branch = Branch.open(other_branch)
2485
if remote_branch.base == local_branch.base:
2486
remote_branch = local_branch
2487
local_branch.lock_read()
2488
try:
2489
remote_branch.lock_read()
2490
try:
2491
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2492
if (log_format is None):
2493
default = local_branch.get_config().log_format()
2494
log_format = get_log_format(long=long, short=short,
2495
line=line, default=default)
2496
lf = log_formatter(log_format,
2497
to_file=self.outf,
2498
show_ids=show_ids,
2499
show_timezone='original')
2500
if reverse is False:
2501
local_extra.reverse()
2502
remote_extra.reverse()
2503
if local_extra and not theirs_only:
2504
print "You have %d extra revision(s):" % len(local_extra)
2505
for data in iter_log_data(local_extra, local_branch.repository,
2506
verbose):
2507
lf.show(*data)
2508
printed_local = True
2509
else:
2510
printed_local = False
2511
if remote_extra and not mine_only:
2512
if printed_local is True:
2513
print "\n\n"
2514
print "You are missing %d revision(s):" % len(remote_extra)
2515
for data in iter_log_data(remote_extra, remote_branch.repository,
2516
verbose):
2517
lf.show(*data)
2518
if not remote_extra and not local_extra:
2519
status_code = 0
2520
print "Branches are up to date."
2521
else:
2522
status_code = 1
2523
finally:
2524
remote_branch.unlock()
2525
finally:
2526
local_branch.unlock()
2527
if not status_code and parent is None and other_branch is not None:
2528
local_branch.lock_write()
2529
try:
2530
# handle race conditions - a parent might be set while we run.
2531
if local_branch.get_parent() is None:
2532
local_branch.set_parent(remote_branch.base)
2533
finally:
2534
local_branch.unlock()
2535
return status_code
1768
2536
1769
2537
1770
2538
class cmd_plugins(Command):
1775
2543
import bzrlib.plugin
1776
2544
from inspect import getdoc
1777
2545
for name, plugin in bzrlib.plugin.all_plugins().items():
1778
if hasattr(plugin, '__path__'):
2546
if getattr(plugin, '__path__', None) is not None:
1779
2547
print plugin.__path__[0]
1780
elif hasattr(plugin, '__file__'):
2548
elif getattr(plugin, '__file__', None) is not None:
1781
2549
print plugin.__file__
1782
2550
else:
1783
print `plugin`
2551
print repr(plugin)
1784
2552
1785
2553
d = getdoc(plugin)
1786
2554
if d:
1789
2557
1790
2558
class cmd_testament(Command):
1791
2559
"""Show testament (signing-form) of a revision."""
1792
takes_options = ['revision', 'long']
2560
takes_options = ['revision',
2561
Option('long', help='Produce long-format testament'),
2562
Option('strict', help='Produce a strict-format'
2563
' testament')]
1793
2564
takes_args = ['branch?']
1794
2565
@display_command
1795
def run(self, branch=u'.', revision=None, long=False):
1796
from bzrlib.testament import Testament
2566
def run(self, branch=u'.', revision=None, long=False, strict=False):
2567
from bzrlib.testament import Testament, StrictTestament
2568
if strict is True:
2569
testament_class = StrictTestament
2570
else:
2571
testament_class = Testament
1797
2572
b = WorkingTree.open_containing(branch)[0].branch
1798
2573
b.lock_read()
1799
2574
try:
1801
2576
rev_id = b.last_revision()
1802
2577
else:
1803
2578
rev_id = revision[0].in_history(b).rev_id
1804
t = Testament.from_revision(b, rev_id)
2579
t = testament_class.from_revision(b.repository, rev_id)
1805
2580
if long:
1806
2581
sys.stdout.writelines(t.as_text_lines())
1807
2582
else:
1820
2595
shown only at the top, unless the --all option is given.
1821
2596
"""
1822
2597
# TODO: annotate directories; showing when each file was last changed
1823
# TODO: annotate a previous version of a file
1824
2598
# TODO: if the working copy is modified, show annotations on that
1825
2599
# with new uncommitted lines marked
1826
aliases = ['blame', 'praise']
2600
aliases = ['ann', 'blame', 'praise']
1827
2601
takes_args = ['filename']
1828
2602
takes_options = [Option('all', help='show annotations on all lines'),
1829
2603
Option('long', help='show date in annotations'),
2604
'revision'
1830
2605
]
1831
2606
1832
2607
@display_command
1833
def run(self, filename, all=False, long=False):
2608
def run(self, filename, all=False, long=False, revision=None):
1834
2609
from bzrlib.annotate import annotate_file
1835
2610
tree, relpath = WorkingTree.open_containing(filename)
1836
2611
branch = tree.branch
1837
2612
branch.lock_read()
1838
2613
try:
2614
if revision is None:
2615
revision_id = branch.last_revision()
2616
elif len(revision) != 1:
2617
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2618
else:
2619
revision_id = revision[0].in_history(branch).rev_id
1839
2620
file_id = tree.inventory.path2id(relpath)
1840
tree = branch.revision_tree(branch.last_revision())
2621
tree = branch.repository.revision_tree(revision_id)
1841
2622
file_version = tree.inventory[file_id].revision
1842
2623
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1843
2624
finally:
1849
2630
# TODO be able to replace existing ones.
1850
2631
1851
2632
hidden = True # is this right ?
1852
takes_args = ['revision_id?']
2633
takes_args = ['revision_id*']
1853
2634
takes_options = ['revision']
1854
2635
1855
def run(self, revision_id=None, revision=None):
1856
import bzrlib.config as config
2636
def run(self, revision_id_list=None, revision=None):
1857
2637
import bzrlib.gpg as gpg
1858
if revision_id is not None and revision is not None:
2638
if revision_id_list is not None and revision is not None:
1859
2639
raise BzrCommandError('You can only supply one of revision_id or --revision')
1860
if revision_id is None and revision is None:
2640
if revision_id_list is None and revision is None:
1861
2641
raise BzrCommandError('You must supply either --revision or a revision_id')
1862
2642
b = WorkingTree.open_containing(u'.')[0].branch
1863
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1864
if revision_id is not None:
1865
b.sign_revision(revision_id, gpg_strategy)
2643
gpg_strategy = gpg.GPGStrategy(b.get_config())
2644
if revision_id_list is not None:
2645
for revision_id in revision_id_list:
2646
b.repository.sign_revision(revision_id, gpg_strategy)
1866
2647
elif revision is not None:
1867
2648
if len(revision) == 1:
1868
2649
revno, rev_id = revision[0].in_history(b)
1869
b.sign_revision(rev_id, gpg_strategy)
2650
b.repository.sign_revision(rev_id, gpg_strategy)
1870
2651
elif len(revision) == 2:
1871
2652
# are they both on rh- if so we can walk between them
1872
2653
# might be nice to have a range helper for arbitrary
1878
2659
if from_revno is None or to_revno is None:
1879
2660
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1880
2661
for revno in range(from_revno, to_revno + 1):
1881
b.sign_revision(b.get_rev_id(revno), gpg_strategy)
2662
b.repository.sign_revision(b.get_rev_id(revno),
2663
gpg_strategy)
1882
2664
else:
1883
2665
raise BzrCommandError('Please supply either one revision, or a range.')
1884
2666
1885
2667
1886
class cmd_uncommit(bzrlib.commands.Command):
2668
class cmd_bind(Command):
2669
"""Bind the current branch to a master branch.
2670
2671
After binding, commits must succeed on the master branch
2672
before they are executed on the local one.
2673
"""
2674
2675
takes_args = ['location']
2676
takes_options = []
2677
2678
def run(self, location=None):
2679
b, relpath = Branch.open_containing(u'.')
2680
b_other = Branch.open(location)
2681
try:
2682
b.bind(b_other)
2683
except DivergedBranches:
2684
raise BzrCommandError('These branches have diverged.'
2685
' Try merging, and then bind again.')
2686
2687
2688
class cmd_unbind(Command):
2689
"""Unbind the current branch from its master branch.
2690
2691
After unbinding, the local branch is considered independent.
2692
All subsequent commits will be local.
2693
"""
2694
2695
takes_args = []
2696
takes_options = []
2697
2698
def run(self):
2699
b, relpath = Branch.open_containing(u'.')
2700
if not b.unbind():
2701
raise BzrCommandError('Local branch is not bound')
2702
2703
2704
class cmd_uncommit(Command):
1887
2705
"""Remove the last committed revision.
1888
2706
1889
By supplying the --all flag, it will not only remove the entry
1890
from revision_history, but also remove all of the entries in the
1891
stores.
1892
1893
2707
--verbose will print out what is being removed.
1894
2708
--dry-run will go through all the motions, but not actually
1895
2709
remove anything.
1896
2710
1897
In the future, uncommit will create a changeset, which can then
2711
In the future, uncommit will create a revision bundle, which can then
1898
2712
be re-applied.
1899
2713
"""
1900
takes_options = ['all', 'verbose', 'revision',
2714
2715
# TODO: jam 20060108 Add an option to allow uncommit to remove
2716
# unreferenced information in 'branch-as-repository' branches.
2717
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2718
# information in shared branches as well.
2719
takes_options = ['verbose', 'revision',
1901
2720
Option('dry-run', help='Don\'t actually make changes'),
1902
2721
Option('force', help='Say yes to all questions.')]
1903
2722
takes_args = ['location?']
1904
2723
aliases = []
1905
2724
1906
def run(self, location=None, all=False,
2725
def run(self, location=None,
1907
2726
dry_run=False, verbose=False,
1908
2727
revision=None, force=False):
1909
from bzrlib.branch import Branch
1910
from bzrlib.log import log_formatter
2728
from bzrlib.log import log_formatter, show_log
1911
2729
import sys
1912
2730
from bzrlib.uncommit import uncommit
1913
2731
1914
2732
if location is None:
1915
2733
location = u'.'
1916
b, relpath = Branch.open_containing(location)
2734
control, relpath = bzrdir.BzrDir.open_containing(location)
2735
try:
2736
tree = control.open_workingtree()
2737
b = tree.branch
2738
except (errors.NoWorkingTree, errors.NotLocalUrl):
2739
tree = None
2740
b = control.open_branch()
1917
2741
2742
rev_id = None
1918
2743
if revision is None:
1919
2744
revno = b.revno()
1920
rev_id = b.last_revision()
1921
2745
else:
1922
revno, rev_id = revision[0].in_history(b)
2746
# 'bzr uncommit -r 10' actually means uncommit
2747
# so that the final tree is at revno 10.
2748
# but bzrlib.uncommit.uncommit() actually uncommits
2749
# the revisions that are supplied.
2750
# So we need to offset it by one
2751
revno = revision[0].in_history(b).revno+1
2752
2753
if revno <= b.revno():
2754
rev_id = b.get_rev_id(revno)
1923
2755
if rev_id is None:
1924
print 'No revisions to uncommit.'
1925
1926
for r in range(revno, b.revno()+1):
1927
rev_id = b.get_rev_id(r)
1928
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
1929
lf.show(r, b.get_revision(rev_id), None)
2756
self.outf.write('No revisions to uncommit.\n')
2757
return 1
2758
2759
lf = log_formatter('short',
2760
to_file=self.outf,
2761
show_timezone='original')
2762
2763
show_log(b,
2764
lf,
2765
verbose=False,
2766
direction='forward',
2767
start_revision=revno,
2768
end_revision=b.revno())
1930
2769
1931
2770
if dry_run:
1932
2771
print 'Dry-run, pretending to remove the above revisions.'
1940
2779
print 'Canceled'
1941
2780
return 0
1942
2781
1943
uncommit(b, remove_files=all,
1944
dry_run=dry_run, verbose=verbose,
2782
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
1945
2783
revno=revno)
1946
2784
1947
2785
2786
class cmd_break_lock(Command):
2787
"""Break a dead lock on a repository, branch or working directory.
2788
2789
CAUTION: Locks should only be broken when you are sure that the process
2790
holding the lock has been stopped.
2791
2792
You can get information on what locks are open via the 'bzr info' command.
2793
2794
example:
2795
bzr break-lock
2796
"""
2797
takes_args = ['location?']
2798
2799
def run(self, location=None, show=False):
2800
if location is None:
2801
location = u'.'
2802
control, relpath = bzrdir.BzrDir.open_containing(location)
2803
try:
2804
control.break_lock()
2805
except NotImplementedError:
2806
pass
2807
2808
2809
class cmd_wait_until_signalled(Command):
2810
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
2811
2812
This just prints a line to signal when it is ready, then blocks on stdin.
2813
"""
2814
2815
hidden = True
2816
2817
def run(self):
2818
sys.stdout.write("running\n")
2819
sys.stdout.flush()
2820
sys.stdin.readline()
2821
2822
2823
class cmd_serve(Command):
2824
"""Run the bzr server."""
2825
2826
aliases = ['server']
2827
2828
takes_options = [
2829
Option('inet',
2830
help='serve on stdin/out for use from inetd or sshd'),
2831
Option('port',
2832
help='listen for connections on nominated port of the form '
2833
'[hostname:]portnumber. Passing 0 as the port number will '
2834
'result in a dynamically allocated port.',
2835
type=str),
2836
Option('directory',
2837
help='serve contents of directory',
2838
type=unicode),
2839
Option('allow-writes',
2840
help='By default the server is a readonly server. Supplying '
2841
'--allow-writes enables write access to the contents of '
2842
'the served directory and below. '
2843
),
2844
]
2845
2846
def run(self, port=None, inet=False, directory=None, allow_writes=False):
2847
from bzrlib.transport import smart
2848
from bzrlib.transport import get_transport
2849
if directory is None:
2850
directory = os.getcwd()
2851
url = urlutils.local_path_to_url(directory)
2852
if not allow_writes:
2853
url = 'readonly+' + url
2854
t = get_transport(url)
2855
if inet:
2856
server = smart.SmartStreamServer(sys.stdin, sys.stdout, t)
2857
elif port is not None:
2858
if ':' in port:
2859
host, port = port.split(':')
2860
else:
2861
host = '127.0.0.1'
2862
server = smart.SmartTCPServer(t, host=host, port=int(port))
2863
print 'listening on port: ', server.port
2864
sys.stdout.flush()
2865
else:
2866
raise BzrCommandError("bzr serve requires one of --inet or --port")
2867
server.serve()
2868
2869
2870
# command-line interpretation helper for merge-related commands
2871
def merge(other_revision, base_revision,
2872
check_clean=True, ignore_zero=False,
2873
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2874
file_list=None, show_base=False, reprocess=False,
2875
pb=DummyProgress()):
2876
"""Merge changes into a tree.
2877
2878
base_revision
2879
list(path, revno) Base for three-way merge.
2880
If [None, None] then a base will be automatically determined.
2881
other_revision
2882
list(path, revno) Other revision for three-way merge.
2883
this_dir
2884
Directory to merge changes into; '.' by default.
2885
check_clean
2886
If true, this_dir must have no uncommitted changes before the
2887
merge begins.
2888
ignore_zero - If true, suppress the "zero conflicts" message when
2889
there are no conflicts; should be set when doing something we expect
2890
to complete perfectly.
2891
file_list - If supplied, merge only changes to selected files.
2892
2893
All available ancestors of other_revision and base_revision are
2894
automatically pulled into the branch.
2895
2896
The revno may be -1 to indicate the last revision on the branch, which is
2897
the typical case.
2898
2899
This function is intended for use from the command line; programmatic
2900
clients might prefer to call merge.merge_inner(), which has less magic
2901
behavior.
2902
"""
2903
from bzrlib.merge import Merger
2904
if this_dir is None:
2905
this_dir = u'.'
2906
this_tree = WorkingTree.open_containing(this_dir)[0]
2907
if show_base and not merge_type is Merge3Merger:
2908
raise BzrCommandError("Show-base is not supported for this merge"
2909
" type. %s" % merge_type)
2910
if reprocess and not merge_type.supports_reprocess:
2911
raise BzrCommandError("Conflict reduction is not supported for merge"
2912
" type %s." % merge_type)
2913
if reprocess and show_base:
2914
raise BzrCommandError("Cannot do conflict reduction and show base.")
2915
try:
2916
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2917
merger.pp = ProgressPhase("Merge phase", 5, pb)
2918
merger.pp.next_phase()
2919
merger.check_basis(check_clean)
2920
merger.set_other(other_revision)
2921
merger.pp.next_phase()
2922
merger.set_base(base_revision)
2923
if merger.base_rev_id == merger.other_rev_id:
2924
note('Nothing to do.')
2925
return 0
2926
merger.backup_files = backup_files
2927
merger.merge_type = merge_type
2928
merger.set_interesting_files(file_list)
2929
merger.show_base = show_base
2930
merger.reprocess = reprocess
2931
conflicts = merger.do_merge()
2932
if file_list is None:
2933
merger.set_pending()
2934
finally:
2935
pb.clear()
2936
return conflicts
2937
2938
1948
2939
# these get imported and then picked up by the scan for cmd_*
1949
2940
# TODO: Some more consistent way to split command definitions across files;
1950
2941
# we do need to load at least some information about them to know of
1951
# aliases.
2942
# aliases. ideally we would avoid loading the implementation until the
2943
# details were needed.
2944
from bzrlib.cmd_version_info import cmd_version_info
1952
2945
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2946
from bzrlib.bundle.commands import cmd_bundle_revisions
2947
from bzrlib.sign_my_commits import cmd_sign_my_commits
2948
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2949
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1