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