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