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