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