« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 2520.4.62
- compare with another revision
- download diff
- download tarball
- view history from revision 2520.4.62
- Committer: Aaron Bentley
- Date: 2007-06-20 22:06:22 UTC
- mto: (2520.5.2 bzr.mpbundle)
- mto: This revision was merged to the branch mainline in revision 2631.
- Revision ID: abentley@panoramicfeedback.com-20070620220622-9lasxr96rr0e0xvn
Use a fresh versionedfile each time
- files added:
- BRANCH.TODO
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins/launchpad
- bzrlib/repofmt
- bzrlib/smart
- bzrlib/store
- 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/per_lock
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/version_info_formats
- doc/developers
- man1
- tools/doc_generate
- tools/win32
- files removed:
- build-api
- bzrlib/util/urlgrabber
- notes
- patches
- files renamed:
- bzrlib/changeset.py => bzrlib/bundle/__init__.py
- bzrlib/store.py => bzrlib/store/__init__.py
- bzrlib/weavestore.py => bzrlib/store/versioned/__init__.py
- bzrlib/selftest/ => bzrlib/tests/
- bzrlib/selftest/teststatus.py => bzrlib/tests/blackbox/test_status.py
- bzrlib/selftest/blackbox.py => bzrlib/tests/blackbox/test_too_much.py
- bzrlib/selftest/versioning.py => bzrlib/tests/blackbox/test_versioning.py
- bzrlib/selftest/testbranch.py => bzrlib/tests/branch_implementations/test_branch.py
- bzrlib/selftest/test_parent.py => bzrlib/tests/branch_implementations/test_parent.py
- bzrlib/selftest/testdiff.py => bzrlib/tests/test_diff.py
- bzrlib/selftest/testfetch.py => bzrlib/tests/test_fetch.py
- bzrlib/selftest/testhashcache.py => bzrlib/tests/test_hashcache.py
- bzrlib/selftest/testinv.py => bzrlib/tests/test_inv.py
- bzrlib/selftest/testlog.py => bzrlib/tests/test_log.py
- bzrlib/selftest/testmerge3.py => bzrlib/tests/test_merge3.py
- bzrlib/selftest/plugins.py => bzrlib/tests/test_plugins.py
- bzrlib/selftest/testrevision.py => bzrlib/tests/test_revision.py
- bzrlib/selftest/testrevisionnamespaces.py => bzrlib/tests/test_revisionnamespaces.py
- bzrlib/selftest/teststore.py => bzrlib/tests/test_store.py
- tools/testweave.py => bzrlib/tests/test_weave.py
- bzrlib/selftest/whitebox.py => bzrlib/tests/test_whitebox.py
- bzrlib/ui.py => bzrlib/ui/__init__.py
- tools/history2weaves.py => bzrlib/upgrade.py
- bzrlib/xml.py => bzrlib/xml_serializer.py
- HACKING => doc/developers/HACKING
- tutorial.txt => doc/tutorial.txt
- bzr-man.py => tools/doc_generate/autodoc_man.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005 by Canonical Ltd
2
1
# Copyright (C) 2004, 2005, 2006, 2007 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
17
"""builtin bzr commands"""
18
19
import os
20
from StringIO import StringIO
21
22
from bzrlib.lazy_import import lazy_import
23
lazy_import(globals(), """
24
import codecs
25
import errno
26
import smtplib
18
27
import sys
19
import os
28
import tempfile
29
import time
20
30
21
31
import bzrlib
22
import bzrlib.trace
23
from bzrlib.trace import mutter, note, log_error, warning
24
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
25
from bzrlib.branch import find_branch
26
from bzrlib import BZRDIR
27
from bzrlib.commands import Command
28
32
from bzrlib import (
33
branch,
34
bugtracker,
35
bundle,
36
bzrdir,
37
delta,
38
config,
39
errors,
40
globbing,
41
ignores,
42
log,
43
merge as _mod_merge,
44
merge_directive,
45
osutils,
46
registry,
47
repository,
48
revisionspec,
49
symbol_versioning,
50
transport,
51
tree as _mod_tree,
52
ui,
53
urlutils,
54
)
55
from bzrlib.branch import Branch
56
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
57
from bzrlib.conflicts import ConflictList
58
from bzrlib.revisionspec import RevisionSpec
59
from bzrlib.workingtree import WorkingTree
60
""")
61
62
from bzrlib.commands import Command, display_command
63
from bzrlib.option import ListOption, Option, RegistryOption
64
from bzrlib.progress import DummyProgress, ProgressPhase
65
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
66
67
68
def tree_files(file_list, default_branch=u'.'):
69
try:
70
return internal_tree_files(file_list, default_branch)
71
except errors.FileInWrongBranch, e:
72
raise errors.BzrCommandError("%s is not in the same branch as %s" %
73
(e.path, file_list[0]))
74
75
76
# XXX: Bad function name; should possibly also be a class method of
77
# WorkingTree rather than a function.
78
def internal_tree_files(file_list, default_branch=u'.'):
79
"""Convert command-line paths to a WorkingTree and relative paths.
80
81
This is typically used for command-line processors that take one or
82
more filenames, and infer the workingtree that contains them.
83
84
The filenames given are not required to exist.
85
86
:param file_list: Filenames to convert.
87
88
:param default_branch: Fallback tree path to use if file_list is empty or
89
None.
90
91
:return: workingtree, [relative_paths]
92
"""
93
if file_list is None or len(file_list) == 0:
94
return WorkingTree.open_containing(default_branch)[0], file_list
95
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
96
new_list = []
97
for filename in file_list:
98
try:
99
new_list.append(tree.relpath(osutils.dereference_path(filename)))
100
except errors.PathNotChild:
101
raise errors.FileInWrongBranch(tree.branch, filename)
102
return tree, new_list
103
104
105
@symbol_versioning.deprecated_function(symbol_versioning.zero_fifteen)
106
def get_format_type(typestring):
107
"""Parse and return a format specifier."""
108
# Have to use BzrDirMetaFormat1 directly, so that
109
# RepositoryFormat.set_default_format works
110
if typestring == "default":
111
return bzrdir.BzrDirMetaFormat1()
112
try:
113
return bzrdir.format_registry.make_bzrdir(typestring)
114
except KeyError:
115
msg = 'Unknown bzr format "%s". See "bzr help formats".' % typestring
116
raise errors.BzrCommandError(msg)
117
118
119
# TODO: Make sure no commands unconditionally use the working directory as a
120
# branch. If a filename argument is used, the first of them should be used to
121
# specify the branch. (Perhaps this can be factored out into some kind of
122
# Argument class, representing a file in a branch, where the first occurrence
123
# opens the branch?)
29
124
30
125
class cmd_status(Command):
31
126
"""Display status summary.
48
143
modified
49
144
Text has changed since the previous revision.
50
145
51
unchanged
52
Nothing about this file has changed since the previous revision.
53
Only shown with --all.
146
kind changed
147
File kind has been changed (e.g. from file to directory).
54
148
55
149
unknown
56
150
Not versioned and not matching an ignore pattern.
57
151
58
To see ignored files use 'bzr ignored'. For details in the
152
To see ignored files use 'bzr ignored'. For details on the
59
153
changes to file texts, use 'bzr diff'.
154
155
--short gives a status flags for each item, similar to the SVN's status
156
command.
157
158
Column 1: versioning / renames
159
+ File versioned
160
- File unversioned
161
R File renamed
162
? File unknown
163
C File has conflicts
164
P Entry for a pending merge (not a file)
165
166
Column 2: Contents
167
N File created
168
D File deleted
169
K File kind changed
170
M File modified
171
172
Column 3: Execute
173
* The execute bit was changed
60
174
61
175
If no arguments are specified, the status of the entire working
62
176
directory is shown. Otherwise, only the status of the specified
63
177
files or directories is reported. If a directory is given, status
64
178
is reported for everything inside that directory.
65
179
66
If a revision is specified, the changes since that revision are shown.
180
If a revision argument is given, the status is calculated against
181
that revision, or between two revisions if two are provided.
67
182
"""
183
184
# TODO: --no-recurse, --recurse options
185
68
186
takes_args = ['file*']
69
takes_options = ['all', 'show-ids', 'revision']
187
takes_options = ['show-ids', 'revision',
188
Option('short', help='Give short SVN-style status lines'),
189
Option('versioned', help='Only show versioned files')]
70
190
aliases = ['st', 'stat']
191
192
encoding_type = 'replace'
193
_see_also = ['diff', 'revert']
71
194
72
def run(self, all=False, show_ids=False, file_list=None):
73
if file_list:
74
b = find_branch(file_list[0])
75
file_list = [b.relpath(x) for x in file_list]
76
# special case: only one path was given and it's the root
77
# of the branch
78
if file_list == ['']:
79
file_list = None
80
else:
81
b = find_branch('.')
195
@display_command
196
def run(self, show_ids=False, file_list=None, revision=None, short=False,
197
versioned=False):
198
from bzrlib.status import show_tree_status
199
200
tree, file_list = tree_files(file_list)
82
201
83
from bzrlib.status import show_status
84
show_status(b, show_unchanged=all, show_ids=show_ids,
85
specific_files=file_list)
202
show_tree_status(tree, show_ids=show_ids,
203
specific_files=file_list, revision=revision,
204
to_file=self.outf, short=short, versioned=versioned)
86
205
87
206
88
207
class cmd_cat_revision(Command):
89
"""Write out metadata for a revision."""
208
"""Write out metadata for a revision.
209
210
The revision to print can either be specified by a specific
211
revision identifier, or you can use --revision.
212
"""
90
213
91
214
hidden = True
92
takes_args = ['revision_id']
93
94
def run(self, revision_id):
95
b = find_branch('.')
96
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
97
215
takes_args = ['revision_id?']
216
takes_options = ['revision']
217
# cat-revision is more for frontends so should be exact
218
encoding = 'strict'
219
220
@display_command
221
def run(self, revision_id=None, revision=None):
222
223
revision_id = osutils.safe_revision_id(revision_id, warn=False)
224
if revision_id is not None and revision is not None:
225
raise errors.BzrCommandError('You can only supply one of'
226
' revision_id or --revision')
227
if revision_id is None and revision is None:
228
raise errors.BzrCommandError('You must supply either'
229
' --revision or a revision_id')
230
b = WorkingTree.open_containing(u'.')[0].branch
231
232
# TODO: jam 20060112 should cat-revision always output utf-8?
233
if revision_id is not None:
234
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
235
elif revision is not None:
236
for rev in revision:
237
if rev is None:
238
raise errors.BzrCommandError('You cannot specify a NULL'
239
' revision.')
240
revno, rev_id = rev.in_history(b)
241
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
242
243
244
class cmd_remove_tree(Command):
245
"""Remove the working tree from a given branch/checkout.
246
247
Since a lightweight checkout is little more than a working tree
248
this will refuse to run against one.
249
250
To re-create the working tree, use "bzr checkout".
251
"""
252
_see_also = ['checkout', 'working-trees']
253
254
takes_args = ['location?']
255
256
def run(self, location='.'):
257
d = bzrdir.BzrDir.open(location)
258
259
try:
260
working = d.open_workingtree()
261
except errors.NoWorkingTree:
262
raise errors.BzrCommandError("No working tree to remove")
263
except errors.NotLocalUrl:
264
raise errors.BzrCommandError("You cannot remove the working tree of a "
265
"remote path")
266
267
working_path = working.bzrdir.root_transport.base
268
branch_path = working.branch.bzrdir.root_transport.base
269
if working_path != branch_path:
270
raise errors.BzrCommandError("You cannot remove the working tree from "
271
"a lightweight checkout")
272
273
d.destroy_workingtree()
274
98
275
99
276
class cmd_revno(Command):
100
277
"""Show current revision number.
101
278
102
This is equal to the number of revisions on this branch."""
103
def run(self):
104
print find_branch('.').revno()
279
This is equal to the number of revisions on this branch.
280
"""
281
282
_see_also = ['info']
283
takes_args = ['location?']
284
285
@display_command
286
def run(self, location=u'.'):
287
self.outf.write(str(Branch.open_containing(location)[0].revno()))
288
self.outf.write('\n')
105
289
106
290
107
291
class cmd_revision_info(Command):
110
294
hidden = True
111
295
takes_args = ['revision_info*']
112
296
takes_options = ['revision']
113
def run(self, revision=None, revision_info_list=None):
114
from bzrlib.branch import find_branch
297
298
@display_command
299
def run(self, revision=None, revision_info_list=[]):
115
300
116
301
revs = []
117
302
if revision is not None:
118
303
revs.extend(revision)
119
304
if revision_info_list is not None:
120
revs.extend(revision_info_list)
305
for rev in revision_info_list:
306
revs.append(RevisionSpec.from_string(rev))
307
308
b = Branch.open_containing(u'.')[0]
309
121
310
if len(revs) == 0:
122
raise BzrCommandError('You must supply a revision identifier')
123
124
b = find_branch('.')
311
revs.append(RevisionSpec.from_string('-1'))
125
312
126
313
for rev in revs:
127
print '%4d %s' % b.get_revision_info(rev)
314
revinfo = rev.in_history(b)
315
if revinfo.revno is None:
316
dotted_map = b.get_revision_id_to_revno_map()
317
revno = '.'.join(str(i) for i in dotted_map[revinfo.rev_id])
318
print '%s %s' % (revno, revinfo.rev_id)
319
else:
320
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
128
321
129
322
130
323
class cmd_add(Command):
145
338
Therefore simply saying 'bzr add' will version all files that
146
339
are currently unknown.
147
340
148
TODO: Perhaps adding a file whose directly is not versioned should
149
recursively add that parent, rather than giving an error?
341
Adding a file whose parent directory is not versioned will
342
implicitly add the parent, and so on up to the root. This means
343
you should never need to explicitly add a directory, they'll just
344
get added when you add a file in the directory.
345
346
--dry-run will show which files would be added, but not actually
347
add them.
348
349
--file-ids-from will try to use the file ids from the supplied path.
350
It looks up ids trying to find a matching parent directory with the
351
same filename, and then by pure path. This option is rarely needed
352
but can be useful when adding the same logical file into two
353
branches that will be merged later (without showing the two different
354
adds as a conflict). It is also useful when merging another project
355
into a subdirectory of this one.
150
356
"""
151
357
takes_args = ['file*']
152
takes_options = ['verbose', 'no-recurse']
153
154
def run(self, file_list, verbose=False, no_recurse=False):
155
# verbose currently has no effect
156
from bzrlib.add import smart_add, add_reporter_print
157
smart_add(file_list, not no_recurse, add_reporter_print)
158
358
takes_options = ['no-recurse', 'dry-run', 'verbose',
359
Option('file-ids-from', type=unicode,
360
help='Lookup file ids from here')]
361
encoding_type = 'replace'
362
_see_also = ['remove']
363
364
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
365
file_ids_from=None):
366
import bzrlib.add
367
368
base_tree = None
369
if file_ids_from is not None:
370
try:
371
base_tree, base_path = WorkingTree.open_containing(
372
file_ids_from)
373
except errors.NoWorkingTree:
374
base_branch, base_path = Branch.open_containing(
375
file_ids_from)
376
base_tree = base_branch.basis_tree()
377
378
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
379
to_file=self.outf, should_print=(not is_quiet()))
380
else:
381
action = bzrlib.add.AddAction(to_file=self.outf,
382
should_print=(not is_quiet()))
383
384
if base_tree:
385
base_tree.lock_read()
386
try:
387
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
388
action=action, save=not dry_run)
389
finally:
390
if base_tree is not None:
391
base_tree.unlock()
392
if len(ignored) > 0:
393
if verbose:
394
for glob in sorted(ignored.keys()):
395
for path in ignored[glob]:
396
self.outf.write("ignored %s matching \"%s\"\n"
397
% (path, glob))
398
else:
399
match_len = 0
400
for glob, paths in ignored.items():
401
match_len += len(paths)
402
self.outf.write("ignored %d file(s).\n" % match_len)
403
self.outf.write("If you wish to add some of these files,"
404
" please add them by name.\n")
159
405
160
406
161
407
class cmd_mkdir(Command):
163
409
164
410
This is equivalent to creating the directory and then adding it.
165
411
"""
412
166
413
takes_args = ['dir+']
414
encoding_type = 'replace'
167
415
168
416
def run(self, dir_list):
169
b = None
170
171
417
for d in dir_list:
172
418
os.mkdir(d)
173
if not b:
174
b = find_branch(d)
175
b.add([d])
176
print 'added', d
419
wt, dd = WorkingTree.open_containing(d)
420
wt.add([dd])
421
self.outf.write('added %s\n' % d)
177
422
178
423
179
424
class cmd_relpath(Command):
180
425
"""Show path of a file relative to root"""
426
181
427
takes_args = ['filename']
182
428
hidden = True
183
429
430
@display_command
184
431
def run(self, filename):
185
print find_branch(filename).relpath(filename)
186
432
# TODO: jam 20050106 Can relpath return a munged path if
433
# sys.stdout encoding cannot represent it?
434
tree, relpath = WorkingTree.open_containing(filename)
435
self.outf.write(relpath)
436
self.outf.write('\n')
187
437
188
438
189
439
class cmd_inventory(Command):
190
"""Show inventory of the current working copy or a revision."""
191
takes_options = ['revision', 'show-ids']
192
193
def run(self, revision=None, show_ids=False):
194
b = find_branch('.')
195
if revision == None:
196
inv = b.read_working_inventory()
197
else:
198
if len(revision) > 1:
199
raise BzrCommandError('bzr inventory --revision takes'
200
' exactly one revision identifier')
201
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
202
203
for path, entry in inv.entries():
440
"""Show inventory of the current working copy or a revision.
441
442
It is possible to limit the output to a particular entry
443
type using the --kind option. For example: --kind file.
444
445
It is also possible to restrict the list of files to a specific
446
set. For example: bzr inventory --show-ids this/file
447
"""
448
449
hidden = True
450
_see_also = ['ls']
451
takes_options = ['revision', 'show-ids', 'kind']
452
takes_args = ['file*']
453
454
@display_command
455
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
456
if kind and kind not in ['file', 'directory', 'symlink']:
457
raise errors.BzrCommandError('invalid kind specified')
458
459
work_tree, file_list = tree_files(file_list)
460
work_tree.lock_read()
461
try:
462
if revision is not None:
463
if len(revision) > 1:
464
raise errors.BzrCommandError(
465
'bzr inventory --revision takes exactly one revision'
466
' identifier')
467
revision_id = revision[0].in_history(work_tree.branch).rev_id
468
tree = work_tree.branch.repository.revision_tree(revision_id)
469
470
extra_trees = [work_tree]
471
tree.lock_read()
472
else:
473
tree = work_tree
474
extra_trees = []
475
476
if file_list is not None:
477
file_ids = tree.paths2ids(file_list, trees=extra_trees,
478
require_versioned=True)
479
# find_ids_across_trees may include some paths that don't
480
# exist in 'tree'.
481
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
482
for file_id in file_ids if file_id in tree)
483
else:
484
entries = tree.inventory.entries()
485
finally:
486
tree.unlock()
487
if tree is not work_tree:
488
work_tree.unlock()
489
490
for path, entry in entries:
491
if kind and kind != entry.kind:
492
continue
204
493
if show_ids:
205
print '%-50s %s' % (path, entry.file_id)
494
self.outf.write('%-50s %s\n' % (path, entry.file_id))
206
495
else:
207
print path
208
209
210
class cmd_move(Command):
211
"""Move files to a different directory.
212
213
examples:
214
bzr move *.txt doc
215
216
The destination must be a versioned directory in the same branch.
217
"""
218
takes_args = ['source$', 'dest']
219
def run(self, source_list, dest):
220
b = find_branch('.')
221
222
# TODO: glob expansion on windows?
223
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
224
225
226
class cmd_rename(Command):
227
"""Change the name of an entry.
228
229
examples:
230
bzr rename frob.c frobber.c
231
bzr rename src/frob.c lib/frob.c
232
233
It is an error if the destination name exists.
234
235
See also the 'move' command, which moves files into a different
236
directory without changing their name.
237
238
TODO: Some way to rename multiple files without invoking bzr for each
239
one?"""
240
takes_args = ['from_name', 'to_name']
241
242
def run(self, from_name, to_name):
243
b = find_branch('.')
244
b.rename_one(b.relpath(from_name), b.relpath(to_name))
245
496
self.outf.write(path)
497
self.outf.write('\n')
246
498
247
499
248
500
class cmd_mv(Command):
254
506
255
507
If the last argument is a versioned directory, all the other names
256
508
are moved into it. Otherwise, there must be exactly two arguments
257
and the file is changed to a new name, which must not already exist.
509
and the file is changed to a new name.
510
511
If OLDNAME does not exist on the filesystem but is versioned and
512
NEWNAME does exist on the filesystem but is not versioned, mv
513
assumes that the file has been manually moved and only updates
514
its internal inventory to reflect that change.
515
The same is valid when moving many SOURCE files to a DESTINATION.
258
516
259
517
Files cannot be moved between branches.
260
518
"""
519
261
520
takes_args = ['names*']
262
def run(self, names_list):
521
takes_options = [Option("after", help="move only the bzr identifier"
522
" of the file (file has already been moved). Use this flag if"
523
" bzr is not able to detect this itself.")]
524
aliases = ['move', 'rename']
525
encoding_type = 'replace'
526
527
def run(self, names_list, after=False):
528
if names_list is None:
529
names_list = []
530
263
531
if len(names_list) < 2:
264
raise BzrCommandError("missing file argument")
265
b = find_branch(names_list[0])
266
267
rel_names = [b.relpath(x) for x in names_list]
532
raise errors.BzrCommandError("missing file argument")
533
tree, rel_names = tree_files(names_list)
268
534
269
535
if os.path.isdir(names_list[-1]):
270
536
# move into existing directory
271
for pair in b.move(rel_names[:-1], rel_names[-1]):
272
print "%s => %s" % pair
537
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
538
self.outf.write("%s => %s\n" % pair)
273
539
else:
274
540
if len(names_list) != 2:
275
raise BzrCommandError('to mv multiple files the destination '
276
'must be a versioned directory')
277
for pair in b.move(rel_names[0], rel_names[1]):
278
print "%s => %s" % pair
541
raise errors.BzrCommandError('to mv multiple files the'
542
' destination must be a versioned'
543
' directory')
544
tree.rename_one(rel_names[0], rel_names[1], after=after)
545
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
279
546
280
547
281
282
283
548
class cmd_pull(Command):
284
"""Pull any changes from another branch into the current one.
285
286
If the location is omitted, the last-used location will be used.
287
Both the revision history and the working directory will be
288
updated.
289
290
This command only works on branches that have not diverged. Branches are
291
considered diverged if both branches have had commits without first
292
pulling from the other.
293
294
If branches have diverged, you can use 'bzr merge' to pull the text changes
295
from one into the other.
296
"""
297
takes_args = ['location?']
298
299
def run(self, location=None):
300
from bzrlib.merge import merge
301
import tempfile
302
from shutil import rmtree
303
import errno
304
from bzrlib.branch import pull_loc
305
306
br_to = find_branch('.')
307
stored_loc = None
308
try:
309
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
310
except IOError, e:
311
if e.errno != errno.ENOENT:
312
raise
313
if location is None:
314
if stored_loc is None:
315
raise BzrCommandError("No pull location known or specified.")
316
else:
317
print "Using last location: %s" % stored_loc
318
location = stored_loc
319
cache_root = tempfile.mkdtemp()
320
from bzrlib.branch import DivergedBranches
321
br_from = find_branch(location)
322
location = pull_loc(br_from)
323
old_revno = br_to.revno()
324
try:
325
from branch import find_cached_branch, DivergedBranches
326
br_from = find_cached_branch(location, cache_root)
327
location = pull_loc(br_from)
328
old_revno = br_to.revno()
329
try:
330
br_to.update_revisions(br_from)
331
except DivergedBranches:
332
raise BzrCommandError("These branches have diverged."
333
" Try merge.")
334
335
merge(('.', -1), ('.', old_revno), check_clean=False)
336
if location != stored_loc:
337
br_to.controlfile("x-pull", "wb").write(location + "\n")
338
finally:
339
rmtree(cache_root)
340
549
"""Turn this branch into a mirror of another branch.
550
551
This command only works on branches that have not diverged. Branches are
552
considered diverged if the destination branch's most recent commit is one
553
that has not been merged (directly or indirectly) into the parent.
554
555
If branches have diverged, you can use 'bzr merge' to integrate the changes
556
from one into the other. Once one branch has merged, the other should
557
be able to pull it again.
558
559
If you want to forget your local changes and just update your branch to
560
match the remote one, use pull --overwrite.
561
562
If there is no default location set, the first pull will set it. After
563
that, you can omit the location to use the default. To change the
564
default, use --remember. The value will only be saved if the remote
565
location can be accessed.
566
"""
567
568
_see_also = ['push', 'update']
569
takes_options = ['remember', 'overwrite', 'revision', 'verbose',
570
Option('directory',
571
help='branch to pull into, '
572
'rather than the one containing the working directory',
573
short_name='d',
574
type=unicode,
575
),
576
]
577
takes_args = ['location?']
578
encoding_type = 'replace'
579
580
def run(self, location=None, remember=False, overwrite=False,
581
revision=None, verbose=False,
582
directory=None):
583
from bzrlib.tag import _merge_tags_if_possible
584
# FIXME: too much stuff is in the command class
585
revision_id = None
586
mergeable = None
587
if directory is None:
588
directory = u'.'
589
try:
590
tree_to = WorkingTree.open_containing(directory)[0]
591
branch_to = tree_to.branch
592
except errors.NoWorkingTree:
593
tree_to = None
594
branch_to = Branch.open_containing(directory)[0]
595
596
reader = None
597
if location is not None:
598
try:
599
mergeable = bundle.read_mergeable_from_url(
600
location)
601
except errors.NotABundle:
602
pass # Continue on considering this url a Branch
603
604
stored_loc = branch_to.get_parent()
605
if location is None:
606
if stored_loc is None:
607
raise errors.BzrCommandError("No pull location known or"
608
" specified.")
609
else:
610
display_url = urlutils.unescape_for_display(stored_loc,
611
self.outf.encoding)
612
self.outf.write("Using saved location: %s\n" % display_url)
613
location = stored_loc
614
615
if mergeable is not None:
616
if revision is not None:
617
raise errors.BzrCommandError(
618
'Cannot use -r with merge directives or bundles')
619
revision_id = mergeable.install_revisions(branch_to.repository)
620
branch_from = branch_to
621
else:
622
branch_from = Branch.open(location)
623
624
if branch_to.get_parent() is None or remember:
625
branch_to.set_parent(branch_from.base)
626
627
if revision is not None:
628
if len(revision) == 1:
629
revision_id = revision[0].in_history(branch_from).rev_id
630
else:
631
raise errors.BzrCommandError(
632
'bzr pull --revision takes one value.')
633
634
old_rh = branch_to.revision_history()
635
if tree_to is not None:
636
result = tree_to.pull(branch_from, overwrite, revision_id,
637
delta._ChangeReporter(unversioned_filter=tree_to.is_ignored))
638
else:
639
result = branch_to.pull(branch_from, overwrite, revision_id)
640
641
result.report(self.outf)
642
if verbose:
643
from bzrlib.log import show_changed_revisions
644
new_rh = branch_to.revision_history()
645
show_changed_revisions(branch_to, old_rh, new_rh,
646
to_file=self.outf)
647
648
649
class cmd_push(Command):
650
"""Update a mirror of this branch.
651
652
The target branch will not have its working tree populated because this
653
is both expensive, and is not supported on remote file systems.
654
655
Some smart servers or protocols *may* put the working tree in place in
656
the future.
657
658
This command only works on branches that have not diverged. Branches are
659
considered diverged if the destination branch's most recent commit is one
660
that has not been merged (directly or indirectly) by the source branch.
661
662
If branches have diverged, you can use 'bzr push --overwrite' to replace
663
the other branch completely, discarding its unmerged changes.
664
665
If you want to ensure you have the different changes in the other branch,
666
do a merge (see bzr help merge) from the other branch, and commit that.
667
After that you will be able to do a push without '--overwrite'.
668
669
If there is no default push location set, the first push will set it.
670
After that, you can omit the location to use the default. To change the
671
default, use --remember. The value will only be saved if the remote
672
location can be accessed.
673
"""
674
675
_see_also = ['pull', 'update', 'working-trees']
676
takes_options = ['remember', 'overwrite', 'verbose',
677
Option('create-prefix',
678
help='Create the path leading up to the branch '
679
'if it does not already exist'),
680
Option('directory',
681
help='branch to push from, '
682
'rather than the one containing the working directory',
683
short_name='d',
684
type=unicode,
685
),
686
Option('use-existing-dir',
687
help='By default push will fail if the target'
688
' directory exists, but does not already'
689
' have a control directory. This flag will'
690
' allow push to proceed.'),
691
]
692
takes_args = ['location?']
693
encoding_type = 'replace'
694
695
def run(self, location=None, remember=False, overwrite=False,
696
create_prefix=False, verbose=False,
697
use_existing_dir=False,
698
directory=None):
699
# FIXME: Way too big! Put this into a function called from the
700
# command.
701
if directory is None:
702
directory = '.'
703
br_from = Branch.open_containing(directory)[0]
704
stored_loc = br_from.get_push_location()
705
if location is None:
706
if stored_loc is None:
707
raise errors.BzrCommandError("No push location known or specified.")
708
else:
709
display_url = urlutils.unescape_for_display(stored_loc,
710
self.outf.encoding)
711
self.outf.write("Using saved location: %s\n" % display_url)
712
location = stored_loc
713
714
to_transport = transport.get_transport(location)
715
716
br_to = repository_to = dir_to = None
717
try:
718
dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
719
except errors.NotBranchError:
720
pass # Didn't find anything
721
else:
722
# If we can open a branch, use its direct repository, otherwise see
723
# if there is a repository without a branch.
724
try:
725
br_to = dir_to.open_branch()
726
except errors.NotBranchError:
727
# Didn't find a branch, can we find a repository?
728
try:
729
repository_to = dir_to.find_repository()
730
except errors.NoRepositoryPresent:
731
pass
732
else:
733
# Found a branch, so we must have found a repository
734
repository_to = br_to.repository
735
push_result = None
736
old_rh = []
737
if dir_to is None:
738
# The destination doesn't exist; create it.
739
# XXX: Refactor the create_prefix/no_create_prefix code into a
740
# common helper function
741
try:
742
to_transport.mkdir('.')
743
except errors.FileExists:
744
if not use_existing_dir:
745
raise errors.BzrCommandError("Target directory %s"
746
" already exists, but does not have a valid .bzr"
747
" directory. Supply --use-existing-dir to push"
748
" there anyway." % location)
749
except errors.NoSuchFile:
750
if not create_prefix:
751
raise errors.BzrCommandError("Parent directory of %s"
752
" does not exist."
753
"\nYou may supply --create-prefix to create all"
754
" leading parent directories."
755
% location)
756
757
_create_prefix(to_transport)
758
759
# Now the target directory exists, but doesn't have a .bzr
760
# directory. So we need to create it, along with any work to create
761
# all of the dependent branches, etc.
762
dir_to = br_from.bzrdir.clone_on_transport(to_transport,
763
revision_id=br_from.last_revision())
764
br_to = dir_to.open_branch()
765
# TODO: Some more useful message about what was copied
766
note('Created new branch.')
767
# We successfully created the target, remember it
768
if br_from.get_push_location() is None or remember:
769
br_from.set_push_location(br_to.base)
770
elif repository_to is None:
771
# we have a bzrdir but no branch or repository
772
# XXX: Figure out what to do other than complain.
773
raise errors.BzrCommandError("At %s you have a valid .bzr control"
774
" directory, but not a branch or repository. This is an"
775
" unsupported configuration. Please move the target directory"
776
" out of the way and try again."
777
% location)
778
elif br_to is None:
779
# We have a repository but no branch, copy the revisions, and then
780
# create a branch.
781
last_revision_id = br_from.last_revision()
782
repository_to.fetch(br_from.repository,
783
revision_id=last_revision_id)
784
br_to = br_from.clone(dir_to, revision_id=last_revision_id)
785
note('Created new branch.')
786
if br_from.get_push_location() is None or remember:
787
br_from.set_push_location(br_to.base)
788
else: # We have a valid to branch
789
# We were able to connect to the remote location, so remember it
790
# we don't need to successfully push because of possible divergence.
791
if br_from.get_push_location() is None or remember:
792
br_from.set_push_location(br_to.base)
793
old_rh = br_to.revision_history()
794
try:
795
try:
796
tree_to = dir_to.open_workingtree()
797
except errors.NotLocalUrl:
798
warning("This transport does not update the working "
799
"tree of: %s. See 'bzr help working-trees' for "
800
"more information." % br_to.base)
801
push_result = br_from.push(br_to, overwrite)
802
except errors.NoWorkingTree:
803
push_result = br_from.push(br_to, overwrite)
804
else:
805
tree_to.lock_write()
806
try:
807
push_result = br_from.push(tree_to.branch, overwrite)
808
tree_to.update()
809
finally:
810
tree_to.unlock()
811
except errors.DivergedBranches:
812
raise errors.BzrCommandError('These branches have diverged.'
813
' Try using "merge" and then "push".')
814
if push_result is not None:
815
push_result.report(self.outf)
816
elif verbose:
817
new_rh = br_to.revision_history()
818
if old_rh != new_rh:
819
# Something changed
820
from bzrlib.log import show_changed_revisions
821
show_changed_revisions(br_to, old_rh, new_rh,
822
to_file=self.outf)
823
else:
824
# we probably did a clone rather than a push, so a message was
825
# emitted above
826
pass
341
827
342
828
343
829
class cmd_branch(Command):
345
831
346
832
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
347
833
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
834
If the FROM_LOCATION has no / or path separator embedded, the TO_LOCATION
835
is derived from the FROM_LOCATION by stripping a leading scheme or drive
836
identifier, if any. For example, "branch lp:foo-bar" will attempt to
837
create ./foo-bar.
348
838
349
839
To retrieve the branch as of a particular revision, supply the --revision
350
840
parameter, as in "branch foo/bar -r 5".
351
841
"""
842
843
_see_also = ['checkout']
352
844
takes_args = ['from_location', 'to_location?']
353
845
takes_options = ['revision']
354
846
aliases = ['get', 'clone']
355
847
356
848
def run(self, from_location, to_location=None, revision=None):
357
from bzrlib.branch import copy_branch, find_cached_branch
358
import tempfile
359
import errno
360
from shutil import rmtree
361
cache_root = tempfile.mkdtemp()
849
from bzrlib.tag import _merge_tags_if_possible
850
if revision is None:
851
revision = [None]
852
elif len(revision) > 1:
853
raise errors.BzrCommandError(
854
'bzr branch --revision takes exactly 1 revision value')
855
856
br_from = Branch.open(from_location)
857
br_from.lock_read()
362
858
try:
363
if revision is None:
364
revision = [None]
365
elif len(revision) > 1:
366
raise BzrCommandError(
367
'bzr branch --revision takes exactly 1 revision value')
368
try:
369
br_from = find_cached_branch(from_location, cache_root)
370
except OSError, e:
371
if e.errno == errno.ENOENT:
372
raise BzrCommandError('Source location "%s" does not'
373
' exist.' % to_location)
374
else:
375
raise
859
if len(revision) == 1 and revision[0] is not None:
860
revision_id = revision[0].in_history(br_from)[1]
861
else:
862
# FIXME - wt.last_revision, fallback to branch, fall back to
863
# None or perhaps NULL_REVISION to mean copy nothing
864
# RBC 20060209
865
revision_id = br_from.last_revision()
376
866
if to_location is None:
377
to_location = os.path.basename(from_location.rstrip("/\\"))
378
try:
379
os.mkdir(to_location)
380
except OSError, e:
381
if e.errno == errno.EEXIST:
382
raise BzrCommandError('Target directory "%s" already'
383
' exists.' % to_location)
384
if e.errno == errno.ENOENT:
385
raise BzrCommandError('Parent of "%s" does not exist.' %
386
to_location)
387
else:
388
raise
389
try:
390
copy_branch(br_from, to_location, revision[0])
391
except bzrlib.errors.NoSuchRevision:
392
rmtree(to_location)
393
msg = "The branch %s has no revision %d." % (from_location, revision[0])
394
raise BzrCommandError(msg)
867
to_location = urlutils.derive_to_location(from_location)
868
name = None
869
else:
870
name = os.path.basename(to_location) + '\n'
871
872
to_transport = transport.get_transport(to_location)
873
try:
874
to_transport.mkdir('.')
875
except errors.FileExists:
876
raise errors.BzrCommandError('Target directory "%s" already'
877
' exists.' % to_location)
878
except errors.NoSuchFile:
879
raise errors.BzrCommandError('Parent of "%s" does not exist.'
880
% to_location)
881
try:
882
# preserve whatever source format we have.
883
dir = br_from.bzrdir.sprout(to_transport.base, revision_id)
884
branch = dir.open_branch()
885
except errors.NoSuchRevision:
886
to_transport.delete_tree('.')
887
msg = "The branch %s has no revision %s." % (from_location, revision[0])
888
raise errors.BzrCommandError(msg)
889
if name:
890
branch.control_files.put_utf8('branch-name', name)
891
_merge_tags_if_possible(br_from, branch)
892
note('Branched %d revision(s).' % branch.revno())
395
893
finally:
396
rmtree(cache_root)
894
br_from.unlock()
895
896
897
class cmd_checkout(Command):
898
"""Create a new checkout of an existing branch.
899
900
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
901
the branch found in '.'. This is useful if you have removed the working tree
902
or if it was never created - i.e. if you pushed the branch to its current
903
location using SFTP.
904
905
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
906
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
907
If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
908
is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
909
identifier, if any. For example, "checkout lp:foo-bar" will attempt to
910
create ./foo-bar.
911
912
To retrieve the branch as of a particular revision, supply the --revision
913
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
914
out of date [so you cannot commit] but it may be useful (i.e. to examine old
915
code.)
916
"""
917
918
_see_also = ['checkouts', 'branch']
919
takes_args = ['branch_location?', 'to_location?']
920
takes_options = ['revision',
921
Option('lightweight',
922
help="perform a lightweight checkout. Lightweight "
923
"checkouts depend on access to the branch for "
924
"every operation. Normal checkouts can perform "
925
"common operations like diff and status without "
926
"such access, and also support local commits."
927
),
928
]
929
aliases = ['co']
930
931
def run(self, branch_location=None, to_location=None, revision=None,
932
lightweight=False):
933
if revision is None:
934
revision = [None]
935
elif len(revision) > 1:
936
raise errors.BzrCommandError(
937
'bzr checkout --revision takes exactly 1 revision value')
938
if branch_location is None:
939
branch_location = osutils.getcwd()
940
to_location = branch_location
941
source = Branch.open(branch_location)
942
if len(revision) == 1 and revision[0] is not None:
943
revision_id = revision[0].in_history(source)[1]
944
else:
945
revision_id = None
946
if to_location is None:
947
to_location = urlutils.derive_to_location(branch_location)
948
# if the source and to_location are the same,
949
# and there is no working tree,
950
# then reconstitute a branch
951
if (osutils.abspath(to_location) ==
952
osutils.abspath(branch_location)):
953
try:
954
source.bzrdir.open_workingtree()
955
except errors.NoWorkingTree:
956
source.bzrdir.create_workingtree()
957
return
958
try:
959
os.mkdir(to_location)
960
except OSError, e:
961
if e.errno == errno.EEXIST:
962
raise errors.BzrCommandError('Target directory "%s" already'
963
' exists.' % to_location)
964
if e.errno == errno.ENOENT:
965
raise errors.BzrCommandError('Parent of "%s" does not exist.'
966
% to_location)
967
else:
968
raise
969
source.create_checkout(to_location, revision_id, lightweight)
397
970
398
971
399
972
class cmd_renames(Command):
400
973
"""Show list of renamed files.
401
402
TODO: Option to show renames between two historical versions.
403
404
TODO: Only show renames under dir, rather than in the whole branch.
405
"""
406
takes_args = ['dir?']
974
"""
975
# TODO: Option to show renames between two historical versions.
976
977
# TODO: Only show renames under dir, rather than in the whole branch.
978
_see_also = ['status']
979
takes_args = ['dir?']
980
981
@display_command
982
def run(self, dir=u'.'):
983
tree = WorkingTree.open_containing(dir)[0]
984
tree.lock_read()
985
try:
986
new_inv = tree.inventory
987
old_tree = tree.basis_tree()
988
old_tree.lock_read()
989
try:
990
old_inv = old_tree.inventory
991
renames = list(_mod_tree.find_renames(old_inv, new_inv))
992
renames.sort()
993
for old_name, new_name in renames:
994
self.outf.write("%s => %s\n" % (old_name, new_name))
995
finally:
996
old_tree.unlock()
997
finally:
998
tree.unlock()
999
1000
1001
class cmd_update(Command):
1002
"""Update a tree to have the latest code committed to its branch.
1003
1004
This will perform a merge into the working tree, and may generate
1005
conflicts. If you have any local changes, you will still
1006
need to commit them after the update for the update to be complete.
1007
1008
If you want to discard your local changes, you can just do a
1009
'bzr revert' instead of 'bzr commit' after the update.
1010
"""
1011
1012
_see_also = ['pull', 'working-trees']
1013
takes_args = ['dir?']
1014
aliases = ['up']
407
1015
408
1016
def run(self, dir='.'):
409
b = find_branch(dir)
410
old_inv = b.basis_tree().inventory
411
new_inv = b.read_working_inventory()
412
413
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
414
renames.sort()
415
for old_name, new_name in renames:
416
print "%s => %s" % (old_name, new_name)
1017
tree = WorkingTree.open_containing(dir)[0]
1018
master = tree.branch.get_master_branch()
1019
if master is not None:
1020
tree.lock_write()
1021
else:
1022
tree.lock_tree_write()
1023
try:
1024
existing_pending_merges = tree.get_parent_ids()[1:]
1025
last_rev = tree.last_revision()
1026
if last_rev == tree.branch.last_revision():
1027
# may be up to date, check master too.
1028
master = tree.branch.get_master_branch()
1029
if master is None or last_rev == master.last_revision():
1030
revno = tree.branch.revision_id_to_revno(last_rev)
1031
note("Tree is up to date at revision %d." % (revno,))
1032
return 0
1033
conflicts = tree.update()
1034
revno = tree.branch.revision_id_to_revno(tree.last_revision())
1035
note('Updated to revision %d.' % (revno,))
1036
if tree.get_parent_ids()[1:] != existing_pending_merges:
1037
note('Your local commits will now show as pending merges with '
1038
"'bzr status', and can be committed with 'bzr commit'.")
1039
if conflicts != 0:
1040
return 1
1041
else:
1042
return 0
1043
finally:
1044
tree.unlock()
417
1045
418
1046
419
1047
class cmd_info(Command):
420
"""Show statistical information about a branch."""
421
takes_args = ['branch?']
422
423
def run(self, branch=None):
424
import info
425
426
b = find_branch(branch)
427
info.show_info(b)
1048
"""Show information about a working tree, branch or repository.
1049
1050
This command will show all known locations and formats associated to the
1051
tree, branch or repository. Statistical information is included with
1052
each report.
1053
1054
Branches and working trees will also report any missing revisions.
1055
"""
1056
_see_also = ['revno', 'working-trees', 'repositories']
1057
takes_args = ['location?']
1058
takes_options = ['verbose']
1059
1060
@display_command
1061
def run(self, location=None, verbose=0):
1062
from bzrlib.info import show_bzrdir_info
1063
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1064
verbose=verbose)
428
1065
429
1066
430
1067
class cmd_remove(Command):
431
"""Make a file unversioned.
432
433
This makes bzr stop tracking changes to a versioned file. It does
434
not delete the working copy.
1068
"""Remove files or directories.
1069
1070
This makes bzr stop tracking changes to the specified files and
1071
delete them if they can easily be recovered using revert.
1072
1073
You can specify one or more files, and/or --new. If you specify --new,
1074
only 'added' files will be removed. If you specify both, then new files
1075
in the specified directories will be removed. If the directories are
1076
also new, they will also be removed.
435
1077
"""
436
takes_args = ['file+']
437
takes_options = ['verbose']
438
439
def run(self, file_list, verbose=False):
440
b = find_branch(file_list[0])
441
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
1078
takes_args = ['file*']
1079
takes_options = ['verbose',
1080
Option('new', help='remove newly-added files'),
1081
RegistryOption.from_kwargs('file-deletion-strategy',
1082
'The file deletion mode to be used',
1083
title='Deletion Strategy', value_switches=True, enum_switch=False,
1084
safe='Only delete files if they can be'
1085
' safely recovered (default).',
1086
keep="Don't delete any files.",
1087
force='Delete all the specified files, even if they can not be '
1088
'recovered and even if they are non-empty directories.')]
1089
aliases = ['rm']
1090
encoding_type = 'replace'
1091
1092
def run(self, file_list, verbose=False, new=False,
1093
file_deletion_strategy='safe'):
1094
tree, file_list = tree_files(file_list)
1095
1096
if file_list is not None:
1097
file_list = [f for f in file_list if f != '']
1098
elif not new:
1099
raise errors.BzrCommandError('Specify one or more files to'
1100
' remove, or use --new.')
1101
1102
if new:
1103
added = tree.changes_from(tree.basis_tree(),
1104
specific_files=file_list).added
1105
file_list = sorted([f[0] for f in added], reverse=True)
1106
if len(file_list) == 0:
1107
raise errors.BzrCommandError('No matching files.')
1108
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1109
keep_files=file_deletion_strategy=='keep',
1110
force=file_deletion_strategy=='force')
442
1111
443
1112
444
1113
class cmd_file_id(Command):
448
1117
same through all revisions where the file exists, even when it is
449
1118
moved or renamed.
450
1119
"""
1120
451
1121
hidden = True
1122
_see_also = ['inventory', 'ls']
452
1123
takes_args = ['filename']
1124
1125
@display_command
453
1126
def run(self, filename):
454
b = find_branch(filename)
455
i = b.inventory.path2id(b.relpath(filename))
456
if i == None:
457
raise BzrError("%r is not a versioned file" % filename)
1127
tree, relpath = WorkingTree.open_containing(filename)
1128
i = tree.path2id(relpath)
1129
if i is None:
1130
raise errors.NotVersionedError(filename)
458
1131
else:
459
print i
1132
self.outf.write(i + '\n')
460
1133
461
1134
462
1135
class cmd_file_path(Command):
463
1136
"""Print path of file_ids to a file or directory.
464
1137
465
1138
This prints one line for each directory down to the target,
466
starting at the branch root."""
1139
starting at the branch root.
1140
"""
1141
467
1142
hidden = True
468
1143
takes_args = ['filename']
1144
1145
@display_command
469
1146
def run(self, filename):
470
b = find_branch(filename)
471
inv = b.inventory
472
fid = inv.path2id(b.relpath(filename))
473
if fid == None:
474
raise BzrError("%r is not a versioned file" % filename)
475
for fip in inv.get_idpath(fid):
476
print fip
1147
tree, relpath = WorkingTree.open_containing(filename)
1148
fid = tree.path2id(relpath)
1149
if fid is None:
1150
raise errors.NotVersionedError(filename)
1151
segments = osutils.splitpath(relpath)
1152
for pos in range(1, len(segments) + 1):
1153
path = osutils.joinpath(segments[:pos])
1154
self.outf.write("%s\n" % tree.path2id(path))
1155
1156
1157
class cmd_reconcile(Command):
1158
"""Reconcile bzr metadata in a branch.
1159
1160
This can correct data mismatches that may have been caused by
1161
previous ghost operations or bzr upgrades. You should only
1162
need to run this command if 'bzr check' or a bzr developer
1163
advises you to run it.
1164
1165
If a second branch is provided, cross-branch reconciliation is
1166
also attempted, which will check that data like the tree root
1167
id which was not present in very early bzr versions is represented
1168
correctly in both branches.
1169
1170
At the same time it is run it may recompress data resulting in
1171
a potential saving in disk space or performance gain.
1172
1173
The branch *MUST* be on a listable system such as local disk or sftp.
1174
"""
1175
1176
_see_also = ['check']
1177
takes_args = ['branch?']
1178
1179
def run(self, branch="."):
1180
from bzrlib.reconcile import reconcile
1181
dir = bzrdir.BzrDir.open(branch)
1182
reconcile(dir)
477
1183
478
1184
479
1185
class cmd_revision_history(Command):
480
"""Display list of revision ids on this branch."""
1186
"""Display the list of revision ids on a branch."""
1187
1188
_see_also = ['log']
1189
takes_args = ['location?']
1190
481
1191
hidden = True
482
def run(self):
483
for patchid in find_branch('.').revision_history():
484
print patchid
1192
1193
@display_command
1194
def run(self, location="."):
1195
branch = Branch.open_containing(location)[0]
1196
for revid in branch.revision_history():
1197
self.outf.write(revid)
1198
self.outf.write('\n')
485
1199
486
1200
487
1201
class cmd_ancestry(Command):
488
1202
"""List all revisions merged into this branch."""
1203
1204
_see_also = ['log', 'revision-history']
1205
takes_args = ['location?']
1206
489
1207
hidden = True
490
def run(self):
491
b = find_branch('.')
492
for revision_id in b.get_ancestry(b.last_patch()):
493
print revision_id
494
495
496
class cmd_directories(Command):
497
"""Display list of versioned directories in this branch."""
498
def run(self):
499
for name, ie in find_branch('.').read_working_inventory().directories():
500
if name == '':
501
print '.'
502
else:
503
print name
1208
1209
@display_command
1210
def run(self, location="."):
1211
try:
1212
wt = WorkingTree.open_containing(location)[0]
1213
except errors.NoWorkingTree:
1214
b = Branch.open(location)
1215
last_revision = b.last_revision()
1216
else:
1217
b = wt.branch
1218
last_revision = wt.last_revision()
1219
1220
revision_ids = b.repository.get_ancestry(last_revision)
1221
assert revision_ids[0] is None
1222
revision_ids.pop(0)
1223
for revision_id in revision_ids:
1224
self.outf.write(revision_id + '\n')
504
1225
505
1226
506
1227
class cmd_init(Command):
509
1230
Use this to create an empty branch, or before importing an
510
1231
existing project.
511
1232
1233
If there is a repository in a parent directory of the location, then
1234
the history of the branch will be stored in the repository. Otherwise
1235
init creates a standalone branch which carries its own history
1236
in the .bzr directory.
1237
1238
If there is already a branch at the location but it has no working tree,
1239
the tree can be populated with 'bzr checkout'.
1240
512
1241
Recipe for importing a tree of files:
513
1242
cd ~/project
514
1243
bzr init
515
bzr add -v .
1244
bzr add .
516
1245
bzr status
517
1246
bzr commit -m 'imported project'
518
1247
"""
519
def run(self):
520
from bzrlib.branch import Branch
521
Branch('.', init=True)
1248
1249
_see_also = ['init-repo', 'branch', 'checkout']
1250
takes_args = ['location?']
1251
takes_options = [
1252
Option('create-prefix',
1253
help='Create the path leading up to the branch '
1254
'if it does not already exist'),
1255
RegistryOption('format',
1256
help='Specify a format for this branch. '
1257
'See "help formats".',
1258
registry=bzrdir.format_registry,
1259
converter=bzrdir.format_registry.make_bzrdir,
1260
value_switches=True,
1261
title="Branch Format",
1262
),
1263
Option('append-revisions-only',
1264
help='Never change revnos or the existing log.'
1265
' Append revisions to it only.')
1266
]
1267
def run(self, location=None, format=None, append_revisions_only=False,
1268
create_prefix=False):
1269
if format is None:
1270
format = bzrdir.format_registry.make_bzrdir('default')
1271
if location is None:
1272
location = u'.'
1273
1274
to_transport = transport.get_transport(location)
1275
1276
# The path has to exist to initialize a
1277
# branch inside of it.
1278
# Just using os.mkdir, since I don't
1279
# believe that we want to create a bunch of
1280
# locations if the user supplies an extended path
1281
try:
1282
to_transport.ensure_base()
1283
except errors.NoSuchFile:
1284
if not create_prefix:
1285
raise errors.BzrCommandError("Parent directory of %s"
1286
" does not exist."
1287
"\nYou may supply --create-prefix to create all"
1288
" leading parent directories."
1289
% location)
1290
_create_prefix(to_transport)
1291
1292
try:
1293
existing_bzrdir = bzrdir.BzrDir.open(location)
1294
except errors.NotBranchError:
1295
# really a NotBzrDir error...
1296
branch = bzrdir.BzrDir.create_branch_convenience(to_transport.base,
1297
format=format)
1298
else:
1299
from bzrlib.transport.local import LocalTransport
1300
if existing_bzrdir.has_branch():
1301
if (isinstance(to_transport, LocalTransport)
1302
and not existing_bzrdir.has_workingtree()):
1303
raise errors.BranchExistsWithoutWorkingTree(location)
1304
raise errors.AlreadyBranchError(location)
1305
else:
1306
branch = existing_bzrdir.create_branch()
1307
existing_bzrdir.create_workingtree()
1308
if append_revisions_only:
1309
try:
1310
branch.set_append_revisions_only(True)
1311
except errors.UpgradeRequired:
1312
raise errors.BzrCommandError('This branch format cannot be set'
1313
' to append-revisions-only. Try --experimental-branch6')
1314
1315
1316
class cmd_init_repository(Command):
1317
"""Create a shared repository to hold branches.
1318
1319
New branches created under the repository directory will store their
1320
revisions in the repository, not in the branch directory.
1321
1322
If the --no-trees option is used then the branches in the repository
1323
will not have working trees by default.
1324
1325
example:
1326
bzr init-repo --no-trees repo
1327
bzr init repo/trunk
1328
bzr checkout --lightweight repo/trunk trunk-checkout
1329
cd trunk-checkout
1330
(add files here)
1331
1332
See 'bzr help repositories' for more information.
1333
"""
1334
1335
_see_also = ['init', 'branch', 'checkout']
1336
takes_args = ["location"]
1337
takes_options = [RegistryOption('format',
1338
help='Specify a format for this repository. See'
1339
' "bzr help formats" for details',
1340
registry=bzrdir.format_registry,
1341
converter=bzrdir.format_registry.make_bzrdir,
1342
value_switches=True, title='Repository format'),
1343
Option('no-trees',
1344
help='Branches in the repository will default to'
1345
' not having a working tree'),
1346
]
1347
aliases = ["init-repo"]
1348
1349
def run(self, location, format=None, no_trees=False):
1350
if format is None:
1351
format = bzrdir.format_registry.make_bzrdir('default')
1352
1353
if location is None:
1354
location = '.'
1355
1356
to_transport = transport.get_transport(location)
1357
to_transport.ensure_base()
1358
1359
newdir = format.initialize_on_transport(to_transport)
1360
repo = newdir.create_repository(shared=True)
1361
repo.set_make_working_trees(not no_trees)
522
1362
523
1363
524
1364
class cmd_diff(Command):
525
"""Show differences in working tree.
1365
"""Show differences in the working tree or between revisions.
526
1366
527
1367
If files are listed, only the changes in those files are listed.
528
1368
Otherwise, all changes for the tree are listed.
529
1369
530
TODO: Allow diff across branches.
531
532
TODO: Option to use external diff command; could be GNU diff, wdiff,
533
or a graphical diff.
534
535
TODO: Python difflib is not exactly the same as unidiff; should
536
either fix it up or prefer to use an external diff.
537
538
TODO: If a directory is given, diff everything under that.
539
540
TODO: Selected-file diff is inefficient and doesn't show you
541
deleted files.
542
543
TODO: This probably handles non-Unix newlines poorly.
1370
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1371
produces patches suitable for "patch -p1".
544
1372
545
1373
examples:
546
1374
bzr diff
1375
Shows the difference in the working tree versus the last commit
547
1376
bzr diff -r1
548
bzr diff -r1:2
1377
Difference between the working tree and revision 1
1378
bzr diff -r1..2
1379
Difference between revision 2 and revision 1
1380
bzr diff --prefix old/:new/
1381
Same as 'bzr diff' but prefix paths with old/ and new/
1382
bzr diff bzr.mine bzr.dev
1383
Show the differences between the two working trees
1384
bzr diff foo.c
1385
Show just the differences for 'foo.c'
549
1386
"""
550
1387
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1388
# or a graphical diff.
1389
1390
# TODO: Python difflib is not exactly the same as unidiff; should
1391
# either fix it up or prefer to use an external diff.
1392
1393
# TODO: Selected-file diff is inefficient and doesn't show you
1394
# deleted files.
1395
1396
# TODO: This probably handles non-Unix newlines poorly.
1397
1398
_see_also = ['status']
551
1399
takes_args = ['file*']
552
takes_options = ['revision', 'diff-options']
1400
takes_options = ['revision', 'diff-options',
1401
Option('prefix', type=str,
1402
short_name='p',
1403
help='Set prefixes to added to old and new filenames, as '
1404
'two values separated by a colon. (eg "old/:new/")'),
1405
]
553
1406
aliases = ['di', 'dif']
554
555
def run(self, revision=None, file_list=None, diff_options=None):
556
from bzrlib.diff import show_diff
557
558
if file_list:
559
b = find_branch(file_list[0])
560
file_list = [b.relpath(f) for f in file_list]
561
if file_list == ['']:
562
# just pointing to top-of-tree
563
file_list = None
1407
encoding_type = 'exact'
1408
1409
@display_command
1410
def run(self, revision=None, file_list=None, diff_options=None,
1411
prefix=None):
1412
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1413
1414
if (prefix is None) or (prefix == '0'):
1415
# diff -p0 format
1416
old_label = ''
1417
new_label = ''
1418
elif prefix == '1':
1419
old_label = 'old/'
1420
new_label = 'new/'
1421
elif ':' in prefix:
1422
old_label, new_label = prefix.split(":")
564
1423
else:
565
b = find_branch('.')
566
567
if revision is not None:
568
if len(revision) == 1:
569
show_diff(b, revision[0], specific_files=file_list,
570
external_diff_options=diff_options)
571
elif len(revision) == 2:
572
show_diff(b, revision[0], specific_files=file_list,
573
external_diff_options=diff_options,
574
revision2=revision[1])
1424
raise errors.BzrCommandError(
1425
'--prefix expects two values separated by a colon'
1426
' (eg "old/:new/")')
1427
1428
if revision and len(revision) > 2:
1429
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1430
' one or two revision specifiers')
1431
1432
try:
1433
tree1, file_list = internal_tree_files(file_list)
1434
tree2 = None
1435
b = None
1436
b2 = None
1437
except errors.FileInWrongBranch:
1438
if len(file_list) != 2:
1439
raise errors.BzrCommandError("Files are in different branches")
1440
1441
tree1, file1 = WorkingTree.open_containing(file_list[0])
1442
tree2, file2 = WorkingTree.open_containing(file_list[1])
1443
if file1 != "" or file2 != "":
1444
# FIXME diff those two files. rbc 20051123
1445
raise errors.BzrCommandError("Files are in different branches")
1446
file_list = None
1447
except errors.NotBranchError:
1448
if (revision is not None and len(revision) == 2
1449
and not revision[0].needs_branch()
1450
and not revision[1].needs_branch()):
1451
# If both revision specs include a branch, we can
1452
# diff them without needing a local working tree
1453
tree1, tree2 = None, None
575
1454
else:
576
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
577
else:
578
show_diff(b, None, specific_files=file_list,
579
external_diff_options=diff_options)
580
581
1455
raise
1456
1457
if tree2 is not None:
1458
if revision is not None:
1459
# FIXME: but there should be a clean way to diff between
1460
# non-default versions of two trees, it's not hard to do
1461
# internally...
1462
raise errors.BzrCommandError(
1463
"Sorry, diffing arbitrary revisions across branches "
1464
"is not implemented yet")
1465
return show_diff_trees(tree1, tree2, sys.stdout,
1466
specific_files=file_list,
1467
external_diff_options=diff_options,
1468
old_label=old_label, new_label=new_label)
1469
1470
return diff_cmd_helper(tree1, file_list, diff_options,
1471
revision_specs=revision,
1472
old_label=old_label, new_label=new_label)
582
1473
583
1474
584
1475
class cmd_deleted(Command):
585
1476
"""List files deleted in the working tree.
1477
"""
1478
# TODO: Show files deleted since a previous revision, or
1479
# between two revisions.
1480
# TODO: Much more efficient way to do this: read in new
1481
# directories with readdir, rather than stating each one. Same
1482
# level of effort but possibly much less IO. (Or possibly not,
1483
# if the directories are very large...)
1484
_see_also = ['status', 'ls']
1485
takes_options = ['show-ids']
586
1486
587
TODO: Show files deleted since a previous revision, or between two revisions.
588
"""
1487
@display_command
589
1488
def run(self, show_ids=False):
590
b = find_branch('.')
591
old = b.basis_tree()
592
new = b.working_tree()
593
594
## TODO: Much more efficient way to do this: read in new
595
## directories with readdir, rather than stating each one. Same
596
## level of effort but possibly much less IO. (Or possibly not,
597
## if the directories are very large...)
598
599
for path, ie in old.inventory.iter_entries():
600
if not new.has_id(ie.file_id):
601
if show_ids:
602
print '%-50s %s' % (path, ie.file_id)
603
else:
604
print path
1489
tree = WorkingTree.open_containing(u'.')[0]
1490
tree.lock_read()
1491
try:
1492
old = tree.basis_tree()
1493
old.lock_read()
1494
try:
1495
for path, ie in old.inventory.iter_entries():
1496
if not tree.has_id(ie.file_id):
1497
self.outf.write(path)
1498
if show_ids:
1499
self.outf.write(' ')
1500
self.outf.write(ie.file_id)
1501
self.outf.write('\n')
1502
finally:
1503
old.unlock()
1504
finally:
1505
tree.unlock()
605
1506
606
1507
607
1508
class cmd_modified(Command):
608
"""List files modified in working tree."""
1509
"""List files modified in working tree.
1510
"""
1511
609
1512
hidden = True
1513
_see_also = ['status', 'ls']
1514
1515
@display_command
610
1516
def run(self):
611
from bzrlib.delta import compare_trees
612
613
b = find_branch('.')
614
td = compare_trees(b.basis_tree(), b.working_tree())
615
616
for path, id, kind in td.modified:
617
print path
618
1517
tree = WorkingTree.open_containing(u'.')[0]
1518
td = tree.changes_from(tree.basis_tree())
1519
for path, id, kind, text_modified, meta_modified in td.modified:
1520
self.outf.write(path + '\n')
619
1521
620
1522
621
1523
class cmd_added(Command):
622
"""List files added in working tree."""
1524
"""List files added in working tree.
1525
"""
1526
623
1527
hidden = True
1528
_see_also = ['status', 'ls']
1529
1530
@display_command
624
1531
def run(self):
625
b = find_branch('.')
626
wt = b.working_tree()
627
basis_inv = b.basis_tree().inventory
628
inv = wt.inventory
629
for file_id in inv:
630
if file_id in basis_inv:
631
continue
632
path = inv.id2path(file_id)
633
if not os.access(b.abspath(path), os.F_OK):
634
continue
635
print path
636
637
1532
wt = WorkingTree.open_containing(u'.')[0]
1533
wt.lock_read()
1534
try:
1535
basis = wt.basis_tree()
1536
basis.lock_read()
1537
try:
1538
basis_inv = basis.inventory
1539
inv = wt.inventory
1540
for file_id in inv:
1541
if file_id in basis_inv:
1542
continue
1543
if inv.is_root(file_id) and len(basis_inv) == 0:
1544
continue
1545
path = inv.id2path(file_id)
1546
if not os.access(osutils.abspath(path), os.F_OK):
1547
continue
1548
self.outf.write(path + '\n')
1549
finally:
1550
basis.unlock()
1551
finally:
1552
wt.unlock()
1553
638
1554
639
1555
class cmd_root(Command):
640
1556
"""Show the tree root directory.
641
1557
642
1558
The root is the nearest enclosing directory with a .bzr control
643
1559
directory."""
1560
644
1561
takes_args = ['filename?']
1562
@display_command
645
1563
def run(self, filename=None):
646
1564
"""Print the branch root."""
647
b = find_branch(filename)
648
print getattr(b, 'base', None) or getattr(b, 'baseurl')
1565
tree = WorkingTree.open_containing(filename)[0]
1566
self.outf.write(tree.basedir + '\n')
1567
1568
1569
def _parse_limit(limitstring):
1570
try:
1571
return int(limitstring)
1572
except ValueError:
1573
msg = "The limit argument must be an integer."
1574
raise errors.BzrCommandError(msg)
649
1575
650
1576
651
1577
class cmd_log(Command):
652
"""Show log of this branch.
653
654
To request a range of logs, you can use the command -r begin:end
655
-r revision requests a specific revision, -r :end or -r begin: are
1578
"""Show log of a branch, file, or directory.
1579
1580
By default show the log of the branch containing the working directory.
1581
1582
To request a range of logs, you can use the command -r begin..end
1583
-r revision requests a specific revision, -r ..end or -r begin.. are
656
1584
also valid.
657
1585
658
--message allows you to give a regular expression, which will be evaluated
659
so that only matching entries will be displayed.
660
661
TODO: Make --revision support uuid: and hash: [future tag:] notation.
662
1586
examples:
1587
bzr log
1588
bzr log foo.c
1589
bzr log -r -10.. http://server/branch
663
1590
"""
664
1591
665
takes_args = ['filename?']
666
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
667
'long', 'message', 'short',]
668
669
def run(self, filename=None, timezone='original',
1592
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1593
1594
takes_args = ['location?']
1595
takes_options = [Option('forward',
1596
help='show from oldest to newest'),
1597
'timezone',
1598
Option('verbose',
1599
short_name='v',
1600
help='show files changed in each revision'),
1601
'show-ids', 'revision',
1602
'log-format',
1603
Option('message',
1604
short_name='m',
1605
help='show revisions whose message matches this regexp',
1606
type=str),
1607
Option('limit',
1608
help='limit the output to the first N revisions',
1609
type=_parse_limit),
1610
]
1611
encoding_type = 'replace'
1612
1613
@display_command
1614
def run(self, location=None, timezone='original',
670
1615
verbose=False,
671
1616
show_ids=False,
672
1617
forward=False,
673
1618
revision=None,
1619
log_format=None,
674
1620
message=None,
675
long=False,
676
short=False):
677
from bzrlib.log import log_formatter, show_log
678
import codecs
679
1621
limit=None):
1622
from bzrlib.log import show_log
1623
assert message is None or isinstance(message, basestring), \
1624
"invalid message argument %r" % message
680
1625
direction = (forward and 'forward') or 'reverse'
681
1626
682
if filename:
683
b = find_branch(filename)
684
fp = b.relpath(filename)
685
if fp:
686
file_id = b.read_working_inventory().path2id(fp)
687
else:
688
file_id = None # points to branch root
689
else:
690
b = find_branch('.')
691
file_id = None
692
693
if revision is None:
694
rev1 = None
695
rev2 = None
696
elif len(revision) == 1:
697
rev1 = rev2 = b.get_revision_info(revision[0])[0]
698
elif len(revision) == 2:
699
rev1 = b.get_revision_info(revision[0])[0]
700
rev2 = b.get_revision_info(revision[1])[0]
701
else:
702
raise BzrCommandError('bzr log --revision takes one or two values.')
703
704
if rev1 == 0:
705
rev1 = None
706
if rev2 == 0:
707
rev2 = None
708
709
mutter('encoding log as %r' % bzrlib.user_encoding)
710
711
# use 'replace' so that we don't abort if trying to write out
712
# in e.g. the default C locale.
713
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
714
715
if not short:
716
log_format = 'long'
717
else:
718
log_format = 'short'
719
lf = log_formatter(log_format,
720
show_ids=show_ids,
721
to_file=outf,
722
show_timezone=timezone)
723
724
show_log(b,
725
lf,
726
file_id,
727
verbose=verbose,
728
direction=direction,
729
start_revision=rev1,
730
end_revision=rev2,
731
search=message)
732
1627
# log everything
1628
file_id = None
1629
if location:
1630
# find the file id to log:
1631
1632
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
1633
location)
1634
if fp != '':
1635
if tree is None:
1636
tree = b.basis_tree()
1637
file_id = tree.path2id(fp)
1638
if file_id is None:
1639
raise errors.BzrCommandError(
1640
"Path does not have any revision history: %s" %
1641
location)
1642
else:
1643
# local dir only
1644
# FIXME ? log the current subdir only RBC 20060203
1645
if revision is not None \
1646
and len(revision) > 0 and revision[0].get_branch():
1647
location = revision[0].get_branch()
1648
else:
1649
location = '.'
1650
dir, relpath = bzrdir.BzrDir.open_containing(location)
1651
b = dir.open_branch()
1652
1653
b.lock_read()
1654
try:
1655
if revision is None:
1656
rev1 = None
1657
rev2 = None
1658
elif len(revision) == 1:
1659
rev1 = rev2 = revision[0].in_history(b).revno
1660
elif len(revision) == 2:
1661
if revision[1].get_branch() != revision[0].get_branch():
1662
# b is taken from revision[0].get_branch(), and
1663
# show_log will use its revision_history. Having
1664
# different branches will lead to weird behaviors.
1665
raise errors.BzrCommandError(
1666
"Log doesn't accept two revisions in different"
1667
" branches.")
1668
if revision[0].spec is None:
1669
# missing begin-range means first revision
1670
rev1 = 1
1671
else:
1672
rev1 = revision[0].in_history(b).revno
1673
1674
if revision[1].spec is None:
1675
# missing end-range means last known revision
1676
rev2 = b.revno()
1677
else:
1678
rev2 = revision[1].in_history(b).revno
1679
else:
1680
raise errors.BzrCommandError(
1681
'bzr log --revision takes one or two values.')
1682
1683
# By this point, the revision numbers are converted to the +ve
1684
# form if they were supplied in the -ve form, so we can do
1685
# this comparison in relative safety
1686
if rev1 > rev2:
1687
(rev2, rev1) = (rev1, rev2)
1688
1689
if log_format is None:
1690
log_format = log.log_formatter_registry.get_default(b)
1691
1692
lf = log_format(show_ids=show_ids, to_file=self.outf,
1693
show_timezone=timezone)
1694
1695
show_log(b,
1696
lf,
1697
file_id,
1698
verbose=verbose,
1699
direction=direction,
1700
start_revision=rev1,
1701
end_revision=rev2,
1702
search=message,
1703
limit=limit)
1704
finally:
1705
b.unlock()
1706
1707
1708
def get_log_format(long=False, short=False, line=False, default='long'):
1709
log_format = default
1710
if long:
1711
log_format = 'long'
1712
if short:
1713
log_format = 'short'
1714
if line:
1715
log_format = 'line'
1716
return log_format
733
1717
734
1718
735
1719
class cmd_touching_revisions(Command):
736
1720
"""Return revision-ids which affected a particular file.
737
1721
738
A more user-friendly interface is "bzr log FILE"."""
1722
A more user-friendly interface is "bzr log FILE".
1723
"""
1724
739
1725
hidden = True
740
1726
takes_args = ["filename"]
1727
1728
@display_command
741
1729
def run(self, filename):
742
b = find_branch(filename)
743
inv = b.read_working_inventory()
744
file_id = inv.path2id(b.relpath(filename))
745
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
746
print "%6d %s" % (revno, what)
1730
tree, relpath = WorkingTree.open_containing(filename)
1731
b = tree.branch
1732
file_id = tree.path2id(relpath)
1733
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1734
self.outf.write("%6d %s\n" % (revno, what))
747
1735
748
1736
749
1737
class cmd_ls(Command):
750
1738
"""List files in a tree.
751
752
TODO: Take a revision or remote path and list that tree instead.
753
1739
"""
754
hidden = True
755
def run(self, revision=None, verbose=False):
756
b = find_branch('.')
757
if revision == None:
758
tree = b.working_tree()
1740
1741
_see_also = ['status', 'cat']
1742
takes_args = ['path?']
1743
# TODO: Take a revision or remote path and list that tree instead.
1744
takes_options = ['verbose', 'revision',
1745
Option('non-recursive',
1746
help='don\'t recurse into sub-directories'),
1747
Option('from-root',
1748
help='Print all paths from the root of the branch.'),
1749
Option('unknown', help='Print unknown files'),
1750
Option('versioned', help='Print versioned files'),
1751
Option('ignored', help='Print ignored files'),
1752
1753
Option('null', help='Null separate the files'),
1754
'kind', 'show-ids'
1755
]
1756
@display_command
1757
def run(self, revision=None, verbose=False,
1758
non_recursive=False, from_root=False,
1759
unknown=False, versioned=False, ignored=False,
1760
null=False, kind=None, show_ids=False, path=None):
1761
1762
if kind and kind not in ('file', 'directory', 'symlink'):
1763
raise errors.BzrCommandError('invalid kind specified')
1764
1765
if verbose and null:
1766
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1767
all = not (unknown or versioned or ignored)
1768
1769
selection = {'I':ignored, '?':unknown, 'V':versioned}
1770
1771
if path is None:
1772
fs_path = '.'
1773
prefix = ''
759
1774
else:
760
tree = b.revision_tree(b.lookup_revision(revision))
761
762
for fp, fc, kind, fid in tree.list_files():
763
if verbose:
764
if kind == 'directory':
765
kindch = '/'
766
elif kind == 'file':
767
kindch = ''
768
else:
769
kindch = '???'
770
771
print '%-8s %s%s' % (fc, fp, kindch)
772
else:
773
print fp
774
1775
if from_root:
1776
raise errors.BzrCommandError('cannot specify both --from-root'
1777
' and PATH')
1778
fs_path = path
1779
prefix = path
1780
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
1781
fs_path)
1782
if from_root:
1783
relpath = u''
1784
elif relpath:
1785
relpath += '/'
1786
if revision is not None:
1787
tree = branch.repository.revision_tree(
1788
revision[0].in_history(branch).rev_id)
1789
elif tree is None:
1790
tree = branch.basis_tree()
1791
1792
tree.lock_read()
1793
try:
1794
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1795
if fp.startswith(relpath):
1796
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1797
if non_recursive and '/' in fp:
1798
continue
1799
if not all and not selection[fc]:
1800
continue
1801
if kind is not None and fkind != kind:
1802
continue
1803
if verbose:
1804
kindch = entry.kind_character()
1805
outstring = '%-8s %s%s' % (fc, fp, kindch)
1806
if show_ids and fid is not None:
1807
outstring = "%-50s %s" % (outstring, fid)
1808
self.outf.write(outstring + '\n')
1809
elif null:
1810
self.outf.write(fp + '\0')
1811
if show_ids:
1812
if fid is not None:
1813
self.outf.write(fid)
1814
self.outf.write('\0')
1815
self.outf.flush()
1816
else:
1817
if fid is not None:
1818
my_id = fid
1819
else:
1820
my_id = ''
1821
if show_ids:
1822
self.outf.write('%-50s %s\n' % (fp, my_id))
1823
else:
1824
self.outf.write(fp + '\n')
1825
finally:
1826
tree.unlock()
775
1827
776
1828
777
1829
class cmd_unknowns(Command):
778
"""List unknown files."""
1830
"""List unknown files.
1831
"""
1832
1833
hidden = True
1834
_see_also = ['ls']
1835
1836
@display_command
779
1837
def run(self):
780
from bzrlib.osutils import quotefn
781
for f in find_branch('.').unknowns():
782
print quotefn(f)
783
1838
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1839
self.outf.write(osutils.quotefn(f) + '\n')
784
1840
785
1841
786
1842
class cmd_ignore(Command):
787
"""Ignore a command or pattern.
1843
"""Ignore specified files or patterns.
788
1844
789
1845
To remove patterns from the ignore list, edit the .bzrignore file.
790
1846
791
If the pattern contains a slash, it is compared to the whole path
792
from the branch root. Otherwise, it is comapred to only the last
793
component of the path.
794
795
Ignore patterns are case-insensitive on case-insensitive systems.
796
797
Note: wildcards must be quoted from the shell on Unix.
1847
Trailing slashes on patterns are ignored.
1848
If the pattern contains a slash or is a regular expression, it is compared
1849
to the whole path from the branch root. Otherwise, it is compared to only
1850
the last component of the path. To match a file only in the root
1851
directory, prepend './'.
1852
1853
Ignore patterns specifying absolute paths are not allowed.
1854
1855
Ignore patterns may include globbing wildcards such as:
1856
? - Matches any single character except '/'
1857
* - Matches 0 or more characters except '/'
1858
/**/ - Matches 0 or more directories in a path
1859
[a-z] - Matches a single character from within a group of characters
1860
1861
Ignore patterns may also be Python regular expressions.
1862
Regular expression ignore patterns are identified by a 'RE:' prefix
1863
followed by the regular expression. Regular expression ignore patterns
1864
may not include named or numbered groups.
1865
1866
Note: ignore patterns containing shell wildcards must be quoted from
1867
the shell on Unix.
798
1868
799
1869
examples:
800
1870
bzr ignore ./Makefile
801
1871
bzr ignore '*.class'
1872
bzr ignore 'lib/**/*.o'
1873
bzr ignore 'RE:lib/.*\.o'
802
1874
"""
803
takes_args = ['name_pattern']
1875
1876
_see_also = ['status', 'ignored']
1877
takes_args = ['name_pattern*']
1878
takes_options = [
1879
Option('old-default-rules',
1880
help='Out the ignore rules bzr < 0.9 always used.')
1881
]
804
1882
805
def run(self, name_pattern):
1883
def run(self, name_pattern_list=None, old_default_rules=None):
806
1884
from bzrlib.atomicfile import AtomicFile
807
import os.path
808
809
b = find_branch('.')
810
ifn = b.abspath('.bzrignore')
811
1885
if old_default_rules is not None:
1886
# dump the rules and exit
1887
for pattern in ignores.OLD_DEFAULTS:
1888
print pattern
1889
return
1890
if not name_pattern_list:
1891
raise errors.BzrCommandError("ignore requires at least one "
1892
"NAME_PATTERN or --old-default-rules")
1893
name_pattern_list = [globbing.normalize_pattern(p)
1894
for p in name_pattern_list]
1895
for name_pattern in name_pattern_list:
1896
if (name_pattern[0] == '/' or
1897
(len(name_pattern) > 1 and name_pattern[1] == ':')):
1898
raise errors.BzrCommandError(
1899
"NAME_PATTERN should not be an absolute path")
1900
tree, relpath = WorkingTree.open_containing(u'.')
1901
ifn = tree.abspath('.bzrignore')
812
1902
if os.path.exists(ifn):
813
1903
f = open(ifn, 'rt')
814
1904
try:
823
1913
824
1914
if igns and igns[-1] != '\n':
825
1915
igns += '\n'
826
igns += name_pattern + '\n'
1916
for name_pattern in name_pattern_list:
1917
igns += name_pattern + '\n'
827
1918
1919
f = AtomicFile(ifn, 'wb')
828
1920
try:
829
f = AtomicFile(ifn, 'wt')
830
1921
f.write(igns.encode('utf-8'))
831
1922
f.commit()
832
1923
finally:
833
1924
f.close()
834
1925
835
inv = b.working_tree().inventory
836
if inv.path2id('.bzrignore'):
837
mutter('.bzrignore is already versioned')
838
else:
839
mutter('need to make new .bzrignore file versioned')
840
b.add(['.bzrignore'])
841
1926
if not tree.path2id('.bzrignore'):
1927
tree.add(['.bzrignore'])
842
1928
843
1929
844
1930
class cmd_ignored(Command):
845
1931
"""List ignored files and the patterns that matched them.
1932
"""
846
1933
847
See also: bzr ignore"""
1934
_see_also = ['ignore']
1935
@display_command
848
1936
def run(self):
849
tree = find_branch('.').working_tree()
850
for path, file_class, kind, file_id in tree.list_files():
851
if file_class != 'I':
852
continue
853
## XXX: Slightly inefficient since this was already calculated
854
pat = tree.is_ignored(path)
855
print '%-50s %s' % (path, pat)
1937
tree = WorkingTree.open_containing(u'.')[0]
1938
tree.lock_read()
1939
try:
1940
for path, file_class, kind, file_id, entry in tree.list_files():
1941
if file_class != 'I':
1942
continue
1943
## XXX: Slightly inefficient since this was already calculated
1944
pat = tree.is_ignored(path)
1945
print '%-50s %s' % (path, pat)
1946
finally:
1947
tree.unlock()
856
1948
857
1949
858
1950
class cmd_lookup_revision(Command):
864
1956
hidden = True
865
1957
takes_args = ['revno']
866
1958
1959
@display_command
867
1960
def run(self, revno):
868
1961
try:
869
1962
revno = int(revno)
870
1963
except ValueError:
871
raise BzrCommandError("not a valid revision-number: %r" % revno)
1964
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
872
1965
873
print find_branch('.').lookup_revision(revno)
1966
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
874
1967
875
1968
876
1969
class cmd_export(Command):
877
"""Export past revision to destination directory.
1970
"""Export current or past revision to a destination directory or archive.
878
1971
879
1972
If no revision is specified this exports the last committed revision.
880
1973
882
1975
given, try to find the format with the extension. If no extension
883
1976
is found exports to a directory (equivalent to --format=dir).
884
1977
885
Root may be the top directory for tar, tgz and tbz2 formats. If none
886
is given, the top directory will be the root name of the file."""
887
# TODO: list known exporters
888
takes_args = ['dest']
1978
If root is supplied, it will be used as the root directory inside
1979
container formats (tar, zip, etc). If it is not supplied it will default
1980
to the exported filename. The root option has no effect for 'dir' format.
1981
1982
If branch is omitted then the branch containing the current working
1983
directory will be used.
1984
1985
Note: Export of tree with non-ASCII filenames to zip is not supported.
1986
1987
Supported formats Autodetected by extension
1988
----------------- -------------------------
1989
dir -
1990
tar .tar
1991
tbz2 .tar.bz2, .tbz2
1992
tgz .tar.gz, .tgz
1993
zip .zip
1994
"""
1995
takes_args = ['dest', 'branch?']
889
1996
takes_options = ['revision', 'format', 'root']
890
def run(self, dest, revision=None, format=None, root=None):
891
import os.path
892
b = find_branch('.')
1997
def run(self, dest, branch=None, revision=None, format=None, root=None):
1998
from bzrlib.export import export
1999
2000
if branch is None:
2001
tree = WorkingTree.open_containing(u'.')[0]
2002
b = tree.branch
2003
else:
2004
b = Branch.open(branch)
2005
893
2006
if revision is None:
894
rev_id = b.last_patch()
2007
# should be tree.last_revision FIXME
2008
rev_id = b.last_revision()
895
2009
else:
896
2010
if len(revision) != 1:
897
raise BzrError('bzr export --revision takes exactly 1 argument')
898
revno, rev_id = b.get_revision_info(revision[0])
899
t = b.revision_tree(rev_id)
900
root, ext = os.path.splitext(dest)
901
if not format:
902
if ext in (".tar",):
903
format = "tar"
904
elif ext in (".gz", ".tgz"):
905
format = "tgz"
906
elif ext in (".bz2", ".tbz2"):
907
format = "tbz2"
908
else:
909
format = "dir"
910
t.export(dest, format, root)
2011
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
2012
rev_id = revision[0].in_history(b).rev_id
2013
t = b.repository.revision_tree(rev_id)
2014
try:
2015
export(t, dest, format, root)
2016
except errors.NoSuchExportFormat, e:
2017
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
911
2018
912
2019
913
2020
class cmd_cat(Command):
914
"""Write a file's text from a previous revision."""
915
916
takes_options = ['revision']
2021
"""Write the contents of a file as of a given revision to standard output.
2022
2023
If no revision is nominated, the last revision is used.
2024
2025
Note: Take care to redirect standard output when using this command on a
2026
binary file.
2027
"""
2028
2029
_see_also = ['ls']
2030
takes_options = ['revision', 'name-from-revision']
917
2031
takes_args = ['filename']
918
919
def run(self, filename, revision=None):
920
if revision == None:
921
raise BzrCommandError("bzr cat requires a revision number")
922
elif len(revision) != 1:
923
raise BzrCommandError("bzr cat --revision takes exactly one number")
924
b = find_branch('.')
925
b.print_file(b.relpath(filename), revision[0])
2032
encoding_type = 'exact'
2033
2034
@display_command
2035
def run(self, filename, revision=None, name_from_revision=False):
2036
if revision is not None and len(revision) != 1:
2037
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2038
" one number")
2039
2040
tree = None
2041
try:
2042
tree, b, relpath = \
2043
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2044
except errors.NotBranchError:
2045
pass
2046
2047
if revision is not None and revision[0].get_branch() is not None:
2048
b = Branch.open(revision[0].get_branch())
2049
if tree is None:
2050
tree = b.basis_tree()
2051
if revision is None:
2052
revision_id = b.last_revision()
2053
else:
2054
revision_id = revision[0].in_history(b).rev_id
2055
2056
cur_file_id = tree.path2id(relpath)
2057
rev_tree = b.repository.revision_tree(revision_id)
2058
old_file_id = rev_tree.path2id(relpath)
2059
2060
if name_from_revision:
2061
if old_file_id is None:
2062
raise errors.BzrCommandError("%r is not present in revision %s"
2063
% (filename, revision_id))
2064
else:
2065
rev_tree.print_file(old_file_id)
2066
elif cur_file_id is not None:
2067
rev_tree.print_file(cur_file_id)
2068
elif old_file_id is not None:
2069
rev_tree.print_file(old_file_id)
2070
else:
2071
raise errors.BzrCommandError("%r is not present in revision %s" %
2072
(filename, revision_id))
926
2073
927
2074
928
2075
class cmd_local_time_offset(Command):
929
2076
"""Show the offset in seconds from GMT to local time."""
930
2077
hidden = True
2078
@display_command
931
2079
def run(self):
932
print bzrlib.osutils.local_time_offset()
2080
print osutils.local_time_offset()
933
2081
934
2082
935
2083
943
2091
within it is committed.
944
2092
945
2093
A selected-file commit may fail in some cases where the committed
946
tree would be invalid, such as trying to commit a file in a
947
newly-added directory that is not itself committed.
948
949
TODO: Run hooks on tree to-be-committed, and after commit.
950
951
TODO: Strict commit that fails if there are unknown or deleted files.
2094
tree would be invalid. Consider::
2095
2096
bzr init foo
2097
mkdir foo/bar
2098
bzr add foo/bar
2099
bzr commit foo -m "committing foo"
2100
bzr mv foo/bar foo/baz
2101
mkdir foo/bar
2102
bzr add foo/bar
2103
bzr commit foo/bar -m "committing bar but not baz"
2104
2105
In the example above, the last commit will fail by design. This gives
2106
the user the opportunity to decide whether they want to commit the
2107
rename at the same time, separately first, or not at all. (As a general
2108
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2109
2110
Note: A selected-file commit after a merge is not yet supported.
952
2111
"""
2112
# TODO: Run hooks on tree to-be-committed, and after commit.
2113
2114
# TODO: Strict commit that fails if there are deleted files.
2115
# (what does "deleted files" mean ??)
2116
2117
# TODO: Give better message for -s, --summary, used by tla people
2118
2119
# XXX: verbose currently does nothing
2120
2121
_see_also = ['bugs', 'uncommit']
953
2122
takes_args = ['selected*']
954
takes_options = ['message', 'file', 'verbose', 'unchanged']
2123
takes_options = ['message', 'verbose',
2124
Option('unchanged',
2125
help='commit even if nothing has changed'),
2126
Option('file', type=str,
2127
short_name='F',
2128
argname='msgfile',
2129
help='file containing commit message'),
2130
Option('strict',
2131
help="refuse to commit if there are unknown "
2132
"files in the working tree."),
2133
ListOption('fixes', type=str,
2134
help="mark a bug as being fixed by this "
2135
"revision."),
2136
Option('local',
2137
help="perform a local only commit in a bound "
2138
"branch. Such commits are not pushed to "
2139
"the master branch until a normal commit "
2140
"is performed."
2141
),
2142
]
955
2143
aliases = ['ci', 'checkin']
956
2144
957
# TODO: Give better message for -s, --summary, used by tla people
2145
def _get_bug_fix_properties(self, fixes, branch):
2146
properties = []
2147
# Configure the properties for bug fixing attributes.
2148
for fixed_bug in fixes:
2149
tokens = fixed_bug.split(':')
2150
if len(tokens) != 2:
2151
raise errors.BzrCommandError(
2152
"Invalid bug %s. Must be in the form of 'tag:id'. "
2153
"Commit refused." % fixed_bug)
2154
tag, bug_id = tokens
2155
try:
2156
bug_url = bugtracker.get_bug_url(tag, branch, bug_id)
2157
except errors.UnknownBugTrackerAbbreviation:
2158
raise errors.BzrCommandError(
2159
'Unrecognized bug %s. Commit refused.' % fixed_bug)
2160
except errors.MalformedBugIdentifier:
2161
raise errors.BzrCommandError(
2162
"Invalid bug identifier for %s. Commit refused."
2163
% fixed_bug)
2164
properties.append('%s fixed' % bug_url)
2165
return '\n'.join(properties)
958
2166
959
# XXX: verbose currently does nothing
960
961
2167
def run(self, message=None, file=None, verbose=True, selected_list=None,
962
unchanged=False):
963
from bzrlib.errors import PointlessCommit
964
from bzrlib.msgeditor import edit_commit_message
965
from bzrlib.status import show_status
966
from cStringIO import StringIO
967
968
b = find_branch('.')
969
if selected_list:
970
selected_list = [b.relpath(s) for s in selected_list]
971
972
if not message and not file:
973
catcher = StringIO()
974
show_status(b, specific_files=selected_list,
975
to_file=catcher)
976
message = edit_commit_message(catcher.getvalue())
977
978
if message is None:
979
raise BzrCommandError("please specify a commit message"
980
" with either --message or --file")
981
elif message and file:
982
raise BzrCommandError("please specify either --message or --file")
983
984
if file:
985
import codecs
986
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
2168
unchanged=False, strict=False, local=False, fixes=None):
2169
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
2170
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
2171
StrictCommitFailed)
2172
from bzrlib.msgeditor import edit_commit_message, \
2173
make_commit_message_template
2174
2175
# TODO: Need a blackbox test for invoking the external editor; may be
2176
# slightly problematic to run this cross-platform.
2177
2178
# TODO: do more checks that the commit will succeed before
2179
# spending the user's valuable time typing a commit message.
2180
2181
properties = {}
2182
2183
tree, selected_list = tree_files(selected_list)
2184
if selected_list == ['']:
2185
# workaround - commit of root of tree should be exactly the same
2186
# as just default commit in that tree, and succeed even though
2187
# selected-file merge commit is not done yet
2188
selected_list = []
2189
2190
bug_property = self._get_bug_fix_properties(fixes, tree.branch)
2191
if bug_property:
2192
properties['bugs'] = bug_property
2193
2194
if local and not tree.branch.get_bound_location():
2195
raise errors.LocalRequiresBoundBranch()
2196
2197
def get_message(commit_obj):
2198
"""Callback to get commit message"""
2199
my_message = message
2200
if my_message is None and not file:
2201
template = make_commit_message_template(tree, selected_list)
2202
my_message = edit_commit_message(template)
2203
if my_message is None:
2204
raise errors.BzrCommandError("please specify a commit"
2205
" message with either --message or --file")
2206
elif my_message and file:
2207
raise errors.BzrCommandError(
2208
"please specify either --message or --file")
2209
if file:
2210
my_message = codecs.open(file, 'rt',
2211
bzrlib.user_encoding).read()
2212
if my_message == "":
2213
raise errors.BzrCommandError("empty commit message specified")
2214
return my_message
2215
2216
if verbose:
2217
reporter = ReportCommitToLog()
2218
else:
2219
reporter = NullCommitReporter()
987
2220
988
2221
try:
989
b.commit(message,
990
specific_files=selected_list,
991
allow_pointless=unchanged)
2222
tree.commit(message_callback=get_message,
2223
specific_files=selected_list,
2224
allow_pointless=unchanged, strict=strict, local=local,
2225
reporter=reporter, revprops=properties)
992
2226
except PointlessCommit:
993
2227
# FIXME: This should really happen before the file is read in;
994
2228
# perhaps prepare the commit; get the message; then actually commit
995
raise BzrCommandError("no changes to commit",
996
["use --unchanged to commit anyhow"])
2229
raise errors.BzrCommandError("no changes to commit."
2230
" use --unchanged to commit anyhow")
2231
except ConflictsInTree:
2232
raise errors.BzrCommandError('Conflicts detected in working '
2233
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
2234
' resolve.')
2235
except StrictCommitFailed:
2236
raise errors.BzrCommandError("Commit refused because there are"
2237
" unknown files in the working tree.")
2238
except errors.BoundBranchOutOfDate, e:
2239
raise errors.BzrCommandError(str(e) + "\n"
2240
'To commit to master branch, run update and then commit.\n'
2241
'You can also pass --local to commit to continue working '
2242
'disconnected.')
997
2243
998
2244
999
2245
class cmd_check(Command):
1001
2247
1002
2248
This command checks various invariants about the branch storage to
1003
2249
detect data corruption or bzr bugs.
1004
1005
If given the --update flag, it will update some optional fields
1006
to help ensure data consistency.
1007
2250
"""
1008
takes_args = ['dir?']
1009
1010
def run(self, dir='.'):
2251
2252
_see_also = ['reconcile']
2253
takes_args = ['branch?']
2254
takes_options = ['verbose']
2255
2256
def run(self, branch=None, verbose=False):
1011
2257
from bzrlib.check import check
1012
1013
check(find_branch(dir))
1014
1015
1016
class cmd_scan_cache(Command):
1017
hidden = True
1018
def run(self):
1019
from bzrlib.hashcache import HashCache
1020
1021
c = HashCache('.')
1022
c.read()
1023
c.scan()
1024
1025
print '%6d stats' % c.stat_count
1026
print '%6d in hashcache' % len(c._cache)
1027
print '%6d files removed from cache' % c.removed_count
1028
print '%6d hashes updated' % c.update_count
1029
print '%6d files changed too recently to cache' % c.danger_count
1030
1031
if c.needs_write:
1032
c.write()
1033
2258
if branch is None:
2259
tree = WorkingTree.open_containing()[0]
2260
branch = tree.branch
2261
else:
2262
branch = Branch.open(branch)
2263
check(branch, verbose)
1034
2264
1035
2265
1036
2266
class cmd_upgrade(Command):
1037
2267
"""Upgrade branch storage to current format.
1038
2268
1039
2269
The check command or bzr developers may sometimes advise you to run
1040
this command.
2270
this command. When the default format has changed you may also be warned
2271
during other operations to upgrade.
1041
2272
"""
1042
takes_args = ['dir?']
1043
1044
def run(self, dir='.'):
2273
2274
_see_also = ['check']
2275
takes_args = ['url?']
2276
takes_options = [
2277
RegistryOption('format',
2278
help='Upgrade to a specific format. See "bzr help'
2279
' formats" for details',
2280
registry=bzrdir.format_registry,
2281
converter=bzrdir.format_registry.make_bzrdir,
2282
value_switches=True, title='Branch format'),
2283
]
2284
2285
def run(self, url='.', format=None):
1045
2286
from bzrlib.upgrade import upgrade
1046
upgrade(find_branch(dir))
1047
2287
if format is None:
2288
format = bzrdir.format_registry.make_bzrdir('default')
2289
upgrade(url, format)
1048
2290
1049
2291
1050
2292
class cmd_whoami(Command):
1051
"""Show bzr user id."""
1052
takes_options = ['email']
1053
1054
def run(self, email=False):
2293
"""Show or set bzr user id.
2294
2295
examples:
2296
bzr whoami --email
2297
bzr whoami 'Frank Chu <fchu@example.com>'
2298
"""
2299
takes_options = [ Option('email',
2300
help='display email address only'),
2301
Option('branch',
2302
help='set identity for the current branch instead of '
2303
'globally'),
2304
]
2305
takes_args = ['name?']
2306
encoding_type = 'replace'
2307
2308
@display_command
2309
def run(self, email=False, branch=False, name=None):
2310
if name is None:
2311
# use branch if we're inside one; otherwise global config
2312
try:
2313
c = Branch.open_containing('.')[0].get_config()
2314
except errors.NotBranchError:
2315
c = config.GlobalConfig()
2316
if email:
2317
self.outf.write(c.user_email() + '\n')
2318
else:
2319
self.outf.write(c.username() + '\n')
2320
return
2321
2322
# display a warning if an email address isn't included in the given name.
1055
2323
try:
1056
b = bzrlib.branch.find_branch('.')
1057
except:
1058
b = None
2324
config.extract_email_address(name)
2325
except errors.NoEmailInUsername, e:
2326
warning('"%s" does not seem to contain an email address. '
2327
'This is allowed, but not recommended.', name)
1059
2328
1060
if email:
1061
print bzrlib.osutils.user_email(b)
1062
else:
1063
print bzrlib.osutils.username(b)
2329
# use global config unless --branch given
2330
if branch:
2331
c = Branch.open_containing('.')[0].get_config()
2332
else:
2333
c = config.GlobalConfig()
2334
c.set_user_option('email', name)
2335
2336
2337
class cmd_nick(Command):
2338
"""Print or set the branch nickname.
2339
2340
If unset, the tree root directory name is used as the nickname
2341
To print the current nickname, execute with no argument.
2342
"""
2343
2344
_see_also = ['info']
2345
takes_args = ['nickname?']
2346
def run(self, nickname=None):
2347
branch = Branch.open_containing(u'.')[0]
2348
if nickname is None:
2349
self.printme(branch)
2350
else:
2351
branch.nick = nickname
2352
2353
@display_command
2354
def printme(self, branch):
2355
print branch.nick
1064
2356
1065
2357
1066
2358
class cmd_selftest(Command):
1067
"""Run internal test suite"""
2359
"""Run internal test suite.
2360
2361
If arguments are given, they are regular expressions that say which tests
2362
should run. Tests matching any expression are run, and other tests are
2363
not run.
2364
2365
Alternatively if --first is given, matching tests are run first and then
2366
all other tests are run. This is useful if you have been working in a
2367
particular area, but want to make sure nothing else was broken.
2368
2369
If --exclude is given, tests that match that regular expression are
2370
excluded, regardless of whether they match --first or not.
2371
2372
To help catch accidential dependencies between tests, the --randomize
2373
option is useful. In most cases, the argument used is the word 'now'.
2374
Note that the seed used for the random number generator is displayed
2375
when this option is used. The seed can be explicitly passed as the
2376
argument to this option if required. This enables reproduction of the
2377
actual ordering used if and when an order sensitive problem is encountered.
2378
2379
If --list-only is given, the tests that would be run are listed. This is
2380
useful when combined with --first, --exclude and/or --randomize to
2381
understand their impact. The test harness reports "Listed nn tests in ..."
2382
instead of "Ran nn tests in ..." when list mode is enabled.
2383
2384
If the global option '--no-plugins' is given, plugins are not loaded
2385
before running the selftests. This has two effects: features provided or
2386
modified by plugins will not be tested, and tests provided by plugins will
2387
not be run.
2388
2389
examples::
2390
bzr selftest ignore
2391
run only tests relating to 'ignore'
2392
bzr --no-plugins selftest -v
2393
disable plugins and list tests as they're run
2394
2395
For each test, that needs actual disk access, bzr create their own
2396
subdirectory in the temporary testing directory (testXXXX.tmp).
2397
By default the name of such subdirectory is based on the name of the test.
2398
If option '--numbered-dirs' is given, bzr will use sequent numbers
2399
of running tests to create such subdirectories. This is default behavior
2400
on Windows because of path length limitation.
2401
"""
2402
# NB: this is used from the class without creating an instance, which is
2403
# why it does not have a self parameter.
2404
def get_transport_type(typestring):
2405
"""Parse and return a transport specifier."""
2406
if typestring == "sftp":
2407
from bzrlib.transport.sftp import SFTPAbsoluteServer
2408
return SFTPAbsoluteServer
2409
if typestring == "memory":
2410
from bzrlib.transport.memory import MemoryServer
2411
return MemoryServer
2412
if typestring == "fakenfs":
2413
from bzrlib.transport.fakenfs import FakeNFSServer
2414
return FakeNFSServer
2415
msg = "No known transport type %s. Supported types are: sftp\n" %\
2416
(typestring)
2417
raise errors.BzrCommandError(msg)
2418
1068
2419
hidden = True
1069
takes_options = ['verbose', 'pattern']
1070
def run(self, verbose=False, pattern=".*"):
2420
takes_args = ['testspecs*']
2421
takes_options = ['verbose',
2422
Option('one',
2423
help='stop when one test fails',
2424
short_name='1',
2425
),
2426
Option('keep-output',
2427
help='keep output directories when tests fail'),
2428
Option('transport',
2429
help='Use a different transport by default '
2430
'throughout the test suite.',
2431
type=get_transport_type),
2432
Option('benchmark', help='run the bzr benchmarks.'),
2433
Option('lsprof-timed',
2434
help='generate lsprof output for benchmarked'
2435
' sections of code.'),
2436
Option('cache-dir', type=str,
2437
help='a directory to cache intermediate'
2438
' benchmark steps'),
2439
Option('clean-output',
2440
help='clean temporary tests directories'
2441
' without running tests'),
2442
Option('first',
2443
help='run all tests, but run specified tests first',
2444
short_name='f',
2445
),
2446
Option('numbered-dirs',
2447
help='use numbered dirs for TestCaseInTempDir'),
2448
Option('list-only',
2449
help='list the tests instead of running them'),
2450
Option('randomize', type=str, argname="SEED",
2451
help='randomize the order of tests using the given'
2452
' seed or "now" for the current time'),
2453
Option('exclude', type=str, argname="PATTERN",
2454
short_name='x',
2455
help='exclude tests that match this regular'
2456
' expression'),
2457
]
2458
encoding_type = 'replace'
2459
2460
def run(self, testspecs_list=None, verbose=None, one=False,
2461
keep_output=False, transport=None, benchmark=None,
2462
lsprof_timed=None, cache_dir=None, clean_output=False,
2463
first=False, numbered_dirs=None, list_only=False,
2464
randomize=None, exclude=None):
1071
2465
import bzrlib.ui
1072
from bzrlib.selftest import selftest
1073
# we don't want progress meters from the tests to go to the
1074
# real output; and we don't want log messages cluttering up
1075
# the real logs.
1076
save_ui = bzrlib.ui.ui_factory
1077
bzrlib.trace.info('running tests...')
2466
from bzrlib.tests import selftest
2467
import bzrlib.benchmarks as benchmarks
2468
from bzrlib.benchmarks import tree_creator
2469
2470
if clean_output:
2471
from bzrlib.tests import clean_selftest_output
2472
clean_selftest_output()
2473
return 0
2474
if keep_output:
2475
trace.warning("notice: selftest --keep-output "
2476
"is no longer supported; "
2477
"test output is always removed")
2478
2479
if numbered_dirs is None and sys.platform == 'win32':
2480
numbered_dirs = True
2481
2482
if cache_dir is not None:
2483
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2484
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
2485
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2486
print
2487
if testspecs_list is not None:
2488
pattern = '|'.join(testspecs_list)
2489
else:
2490
pattern = ".*"
2491
if benchmark:
2492
test_suite_factory = benchmarks.test_suite
2493
if verbose is None:
2494
verbose = True
2495
# TODO: should possibly lock the history file...
2496
benchfile = open(".perf_history", "at", buffering=1)
2497
else:
2498
test_suite_factory = None
2499
if verbose is None:
2500
verbose = False
2501
benchfile = None
1078
2502
try:
1079
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1080
result = selftest(verbose=verbose, pattern=pattern)
1081
if result:
1082
bzrlib.trace.info('tests passed')
1083
else:
1084
bzrlib.trace.info('tests failed')
1085
return int(not result)
2503
result = selftest(verbose=verbose,
2504
pattern=pattern,
2505
stop_on_failure=one,
2506
transport=transport,
2507
test_suite_factory=test_suite_factory,
2508
lsprof_timed=lsprof_timed,
2509
bench_history=benchfile,
2510
matching_tests_first=first,
2511
numbered_dirs=numbered_dirs,
2512
list_only=list_only,
2513
random_seed=randomize,
2514
exclude_pattern=exclude
2515
)
1086
2516
finally:
1087
bzrlib.ui.ui_factory = save_ui
1088
1089
1090
def show_version():
1091
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1092
# is bzrlib itself in a branch?
1093
bzrrev = bzrlib.get_bzr_revision()
1094
if bzrrev:
1095
print " (bzr checkout, revision %d {%s})" % bzrrev
1096
print bzrlib.__copyright__
1097
print "http://bazaar-ng.org/"
1098
print
1099
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1100
print "you may use, modify and redistribute it under the terms of the GNU"
1101
print "General Public License version 2 or later."
2517
if benchfile is not None:
2518
benchfile.close()
2519
if result:
2520
info('tests passed')
2521
else:
2522
info('tests failed')
2523
return int(not result)
1102
2524
1103
2525
1104
2526
class cmd_version(Command):
1105
2527
"""Show version of bzr."""
2528
2529
@display_command
1106
2530
def run(self):
2531
from bzrlib.version import show_version
1107
2532
show_version()
1108
2533
2534
1109
2535
class cmd_rocks(Command):
1110
2536
"""Statement of optimism."""
2537
1111
2538
hidden = True
2539
2540
@display_command
1112
2541
def run(self):
1113
print "it sure does!"
2542
print "It sure does!"
1114
2543
1115
2544
1116
2545
class cmd_find_merge_base(Command):
1117
"""Find and print a base revision for merging two branches.
1118
1119
TODO: Options to specify revisions on either side, as if
1120
merging only part of the history.
1121
"""
2546
"""Find and print a base revision for merging two branches."""
2547
# TODO: Options to specify revisions on either side, as if
2548
# merging only part of the history.
1122
2549
takes_args = ['branch', 'other']
1123
2550
hidden = True
1124
2551
2552
@display_command
1125
2553
def run(self, branch, other):
1126
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1127
1128
branch1 = find_branch(branch)
1129
branch2 = find_branch(other)
1130
1131
history_1 = branch1.revision_history()
1132
history_2 = branch2.revision_history()
1133
1134
last1 = branch1.last_patch()
1135
last2 = branch2.last_patch()
1136
1137
source = MultipleRevisionSources(branch1, branch2)
1138
1139
base_rev_id = common_ancestor(last1, last2, source)
2554
from bzrlib.revision import ensure_null, MultipleRevisionSources
2555
2556
branch1 = Branch.open_containing(branch)[0]
2557
branch2 = Branch.open_containing(other)[0]
2558
2559
last1 = ensure_null(branch1.last_revision())
2560
last2 = ensure_null(branch2.last_revision())
2561
2562
graph = branch1.repository.get_graph(branch2.repository)
2563
base_rev_id = graph.find_unique_lca(last1, last2)
1140
2564
1141
2565
print 'merge base is revision %s' % base_rev_id
1142
1143
return
1144
1145
if base_revno is None:
1146
raise bzrlib.errors.UnrelatedBranches()
1147
1148
print ' r%-6d in %s' % (base_revno, branch)
1149
1150
other_revno = branch2.revision_id_to_revno(base_revid)
1151
1152
print ' r%-6d in %s' % (other_revno, other)
1153
1154
2566
1155
2567
1156
2568
class cmd_merge(Command):
1157
2569
"""Perform a three-way merge.
1158
2570
1159
The branch is the branch you will merge from. By default, it will
1160
merge the latest revision. If you specify a revision, that
1161
revision will be merged. If you specify two revisions, the first
1162
will be used as a BASE, and the second one as OTHER. Revision
1163
numbers are always relative to the specified branch.
2571
The branch is the branch you will merge from. By default, it will merge
2572
the latest revision. If you specify a revision, that revision will be
2573
merged. If you specify two revisions, the first will be used as a BASE,
2574
and the second one as OTHER. Revision numbers are always relative to the
2575
specified branch.
1164
2576
1165
By default bzr will try to merge in all new work from the other
2577
By default, bzr will try to merge in all new work from the other
1166
2578
branch, automatically determining an appropriate base. If this
1167
2579
fails, you may need to give an explicit base.
1168
2580
2581
Merge will do its best to combine the changes in two branches, but there
2582
are some kinds of problems only a human can fix. When it encounters those,
2583
it will mark a conflict. A conflict means that you need to fix something,
2584
before you should commit.
2585
2586
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2587
2588
If there is no default branch set, the first merge will set it. After
2589
that, you can omit the branch to use the default. To change the
2590
default, use --remember. The value will only be saved if the remote
2591
location can be accessed.
2592
2593
The results of the merge are placed into the destination working
2594
directory, where they can be reviewed (with bzr diff), tested, and then
2595
committed to record the result of the merge.
2596
1169
2597
Examples:
1170
2598
1171
To merge the latest revision from bzr.dev
1172
bzr merge ../bzr.dev
2599
To merge the latest revision from bzr.dev:
2600
bzr merge ../bzr.dev
1173
2601
1174
To merge changes up to and including revision 82 from bzr.dev
1175
bzr merge -r 82 ../bzr.dev
2602
To merge changes up to and including revision 82 from bzr.dev:
2603
bzr merge -r 82 ../bzr.dev
1176
2604
1177
2605
To merge the changes introduced by 82, without previous changes:
1178
bzr merge -r 81..82 ../bzr.dev
2606
bzr merge -r 81..82 ../bzr.dev
1179
2607
1180
2608
merge refuses to run if there are any uncommitted changes, unless
1181
2609
--force is given.
1182
2610
"""
2611
2612
_see_also = ['update', 'remerge']
1183
2613
takes_args = ['branch?']
1184
takes_options = ['revision', 'force', 'merge-type']
2614
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2615
Option('show-base', help="Show base revision text in "
2616
"conflicts"),
2617
Option('uncommitted', help='Apply uncommitted changes'
2618
' from a working copy, instead of branch changes'),
2619
Option('pull', help='If the destination is already'
2620
' completely merged into the source, pull from the'
2621
' source rather than merging. When this happens,'
2622
' you do not need to commit the result.'),
2623
Option('directory',
2624
help='Branch to merge into, '
2625
'rather than the one containing the working directory',
2626
short_name='d',
2627
type=unicode,
2628
),
2629
]
1185
2630
1186
def run(self, branch='.', revision=None, force=False,
1187
merge_type=None):
1188
from bzrlib.merge import merge
1189
from bzrlib.merge_core import ApplyMerge3
2631
def run(self, branch=None, revision=None, force=False, merge_type=None,
2632
show_base=False, reprocess=False, remember=False,
2633
uncommitted=False, pull=False,
2634
directory=None,
2635
):
2636
from bzrlib.tag import _merge_tags_if_possible
2637
other_revision_id = None
1190
2638
if merge_type is None:
1191
merge_type = ApplyMerge3
2639
merge_type = _mod_merge.Merge3Merger
2640
2641
if directory is None: directory = u'.'
2642
# XXX: jam 20070225 WorkingTree should be locked before you extract its
2643
# inventory. Because merge is a mutating operation, it really
2644
# should be a lock_write() for the whole cmd_merge operation.
2645
# However, cmd_merge open's its own tree in _merge_helper, which
2646
# means if we lock here, the later lock_write() will always block.
2647
# Either the merge helper code should be updated to take a tree,
2648
# (What about tree.merge_from_branch?)
2649
tree = WorkingTree.open_containing(directory)[0]
2650
change_reporter = delta._ChangeReporter(
2651
unversioned_filter=tree.is_ignored)
2652
2653
if branch is not None:
2654
try:
2655
mergeable = bundle.read_mergeable_from_url(
2656
branch)
2657
except errors.NotABundle:
2658
pass # Continue on considering this url a Branch
2659
else:
2660
if revision is not None:
2661
raise errors.BzrCommandError(
2662
'Cannot use -r with merge directives or bundles')
2663
other_revision_id = mergeable.install_revisions(
2664
tree.branch.repository)
2665
revision = [RevisionSpec.from_string(
2666
'revid:' + other_revision_id)]
2667
2668
if revision is None \
2669
or len(revision) < 1 or revision[0].needs_branch():
2670
branch = self._get_remembered_parent(tree, branch, 'Merging from')
1192
2671
1193
2672
if revision is None or len(revision) < 1:
1194
base = [None, None]
1195
other = [branch, -1]
2673
if uncommitted:
2674
base = [branch, -1]
2675
other = [branch, None]
2676
else:
2677
base = [None, None]
2678
other = [branch, -1]
2679
other_branch, path = Branch.open_containing(branch)
1196
2680
else:
2681
if uncommitted:
2682
raise errors.BzrCommandError('Cannot use --uncommitted and'
2683
' --revision at the same time.')
2684
branch = revision[0].get_branch() or branch
1197
2685
if len(revision) == 1:
1198
other = [branch, revision[0]]
1199
2686
base = [None, None]
2687
if other_revision_id is not None:
2688
other_branch = None
2689
path = ""
2690
other = None
2691
else:
2692
other_branch, path = Branch.open_containing(branch)
2693
revno = revision[0].in_history(other_branch).revno
2694
other = [branch, revno]
1200
2695
else:
1201
2696
assert len(revision) == 2
1202
2697
if None in revision:
1203
raise BzrCommandError(
1204
"Merge doesn't permit that revision specifier.")
1205
base = [branch, revision[0]]
1206
other = [branch, revision[1]]
1207
2698
raise errors.BzrCommandError(
2699
"Merge doesn't permit empty revision specifier.")
2700
base_branch, path = Branch.open_containing(branch)
2701
branch1 = revision[1].get_branch() or branch
2702
other_branch, path1 = Branch.open_containing(branch1)
2703
if revision[0].get_branch() is not None:
2704
# then path was obtained from it, and is None.
2705
path = path1
2706
2707
base = [branch, revision[0].in_history(base_branch).revno]
2708
other = [branch1, revision[1].in_history(other_branch).revno]
2709
2710
if ((tree.branch.get_parent() is None or remember) and
2711
other_branch is not None):
2712
tree.branch.set_parent(other_branch.base)
2713
2714
# pull tags now... it's a bit inconsistent to do it ahead of copying
2715
# the history but that's done inside the merge code
2716
if other_branch is not None:
2717
_merge_tags_if_possible(other_branch, tree.branch)
2718
2719
if path != "":
2720
interesting_files = [path]
2721
else:
2722
interesting_files = None
2723
pb = ui.ui_factory.nested_progress_bar()
1208
2724
try:
1209
merge(other, base, check_clean=(not force), merge_type=merge_type)
1210
except bzrlib.errors.AmbiguousBase, e:
2725
try:
2726
conflict_count = _merge_helper(
2727
other, base, other_rev_id=other_revision_id,
2728
check_clean=(not force),
2729
merge_type=merge_type,
2730
reprocess=reprocess,
2731
show_base=show_base,
2732
pull=pull,
2733
this_dir=directory,
2734
pb=pb, file_list=interesting_files,
2735
change_reporter=change_reporter)
2736
finally:
2737
pb.finished()
2738
if conflict_count != 0:
2739
return 1
2740
else:
2741
return 0
2742
except errors.AmbiguousBase, e:
1211
2743
m = ("sorry, bzr can't determine the right merge base yet\n"
1212
2744
"candidates are:\n "
1213
2745
+ "\n ".join(e.bases)
1216
2748
"and (if you want) report this to the bzr developers\n")
1217
2749
log_error(m)
1218
2750
2751
# TODO: move up to common parent; this isn't merge-specific anymore.
2752
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2753
"""Use tree.branch's parent if none was supplied.
2754
2755
Report if the remembered location was used.
2756
"""
2757
if supplied_location is not None:
2758
return supplied_location
2759
stored_location = tree.branch.get_parent()
2760
mutter("%s", stored_location)
2761
if stored_location is None:
2762
raise errors.BzrCommandError("No location specified or remembered")
2763
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2764
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2765
return stored_location
2766
2767
2768
class cmd_remerge(Command):
2769
"""Redo a merge.
2770
2771
Use this if you want to try a different merge technique while resolving
2772
conflicts. Some merge techniques are better than others, and remerge
2773
lets you try different ones on different files.
2774
2775
The options for remerge have the same meaning and defaults as the ones for
2776
merge. The difference is that remerge can (only) be run when there is a
2777
pending merge, and it lets you specify particular files.
2778
2779
Examples:
2780
2781
$ bzr remerge --show-base
2782
Re-do the merge of all conflicted files, and show the base text in
2783
conflict regions, in addition to the usual THIS and OTHER texts.
2784
2785
$ bzr remerge --merge-type weave --reprocess foobar
2786
Re-do the merge of "foobar", using the weave merge algorithm, with
2787
additional processing to reduce the size of conflict regions.
2788
"""
2789
takes_args = ['file*']
2790
takes_options = ['merge-type', 'reprocess',
2791
Option('show-base', help="Show base revision text in "
2792
"conflicts")]
2793
2794
def run(self, file_list=None, merge_type=None, show_base=False,
2795
reprocess=False):
2796
if merge_type is None:
2797
merge_type = _mod_merge.Merge3Merger
2798
tree, file_list = tree_files(file_list)
2799
tree.lock_write()
2800
try:
2801
parents = tree.get_parent_ids()
2802
if len(parents) != 2:
2803
raise errors.BzrCommandError("Sorry, remerge only works after normal"
2804
" merges. Not cherrypicking or"
2805
" multi-merges.")
2806
repository = tree.branch.repository
2807
graph = repository.get_graph()
2808
base_revision = graph.find_unique_lca(parents[0], parents[1])
2809
base_tree = repository.revision_tree(base_revision)
2810
other_tree = repository.revision_tree(parents[1])
2811
interesting_ids = None
2812
new_conflicts = []
2813
conflicts = tree.conflicts()
2814
if file_list is not None:
2815
interesting_ids = set()
2816
for filename in file_list:
2817
file_id = tree.path2id(filename)
2818
if file_id is None:
2819
raise errors.NotVersionedError(filename)
2820
interesting_ids.add(file_id)
2821
if tree.kind(file_id) != "directory":
2822
continue
2823
2824
for name, ie in tree.inventory.iter_entries(file_id):
2825
interesting_ids.add(ie.file_id)
2826
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2827
else:
2828
# Remerge only supports resolving contents conflicts
2829
allowed_conflicts = ('text conflict', 'contents conflict')
2830
restore_files = [c.path for c in conflicts
2831
if c.typestring in allowed_conflicts]
2832
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2833
tree.set_conflicts(ConflictList(new_conflicts))
2834
if file_list is not None:
2835
restore_files = file_list
2836
for filename in restore_files:
2837
try:
2838
restore(tree.abspath(filename))
2839
except errors.NotConflicted:
2840
pass
2841
conflicts = _mod_merge.merge_inner(
2842
tree.branch, other_tree, base_tree,
2843
this_tree=tree,
2844
interesting_ids=interesting_ids,
2845
other_rev_id=parents[1],
2846
merge_type=merge_type,
2847
show_base=show_base,
2848
reprocess=reprocess)
2849
finally:
2850
tree.unlock()
2851
if conflicts > 0:
2852
return 1
2853
else:
2854
return 0
2855
1219
2856
1220
2857
class cmd_revert(Command):
1221
"""Reverse all changes since the last commit.
1222
1223
Only versioned files are affected. Specify filenames to revert only
1224
those files. By default, any files that are changed will be backed up
1225
first. Backup files have a '~' appended to their name.
2858
"""Revert files to a previous revision.
2859
2860
Giving a list of files will revert only those files. Otherwise, all files
2861
will be reverted. If the revision is not specified with '--revision', the
2862
last committed revision is used.
2863
2864
To remove only some changes, without reverting to a prior version, use
2865
merge instead. For example, "merge . --r-2..-3" will remove the changes
2866
introduced by -2, without affecting the changes introduced by -1. Or
2867
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2868
2869
By default, any files that have been manually changed will be backed up
2870
first. (Files changed only by merge are not backed up.) Backup files have
2871
'.~#~' appended to their name, where # is a number.
2872
2873
When you provide files, you can use their current pathname or the pathname
2874
from the target revision. So you can use revert to "undelete" a file by
2875
name. If you name a directory, all the contents of that directory will be
2876
reverted.
1226
2877
"""
2878
2879
_see_also = ['cat', 'export']
1227
2880
takes_options = ['revision', 'no-backup']
1228
2881
takes_args = ['file*']
1229
aliases = ['merge-revert']
1230
2882
1231
2883
def run(self, revision=None, no_backup=False, file_list=None):
1232
from bzrlib.merge import merge
1233
from bzrlib.branch import Branch
1234
from bzrlib.commands import parse_spec
1235
1236
2884
if file_list is not None:
1237
2885
if len(file_list) == 0:
1238
raise BzrCommandError("No files specified")
2886
raise errors.BzrCommandError("No files specified")
2887
else:
2888
file_list = []
2889
2890
tree, file_list = tree_files(file_list)
1239
2891
if revision is None:
1240
revision = [-1]
2892
# FIXME should be tree.last_revision
2893
rev_id = tree.last_revision()
1241
2894
elif len(revision) != 1:
1242
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1243
merge(('.', revision[0]), parse_spec('.'),
1244
check_clean=False,
1245
ignore_zero=True,
1246
backup_files=not no_backup,
1247
file_list=file_list)
1248
if not file_list:
1249
Branch('.').set_pending_merges([])
2895
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
2896
else:
2897
rev_id = revision[0].in_history(tree.branch).rev_id
2898
pb = ui.ui_factory.nested_progress_bar()
2899
try:
2900
tree.revert(file_list,
2901
tree.branch.repository.revision_tree(rev_id),
2902
not no_backup, pb, report_changes=True)
2903
finally:
2904
pb.finished()
1250
2905
1251
2906
1252
2907
class cmd_assert_fail(Command):
1253
2908
"""Test reporting of assertion failures"""
2909
# intended just for use in testing
2910
1254
2911
hidden = True
2912
1255
2913
def run(self):
1256
assert False, "always fails"
2914
raise AssertionError("always fails")
1257
2915
1258
2916
1259
2917
class cmd_help(Command):
1260
2918
"""Show help on a command or other topic.
2919
"""
1261
2920
1262
For a list of all available commands, say 'bzr help commands'."""
1263
takes_options = ['long']
2921
_see_also = ['topics']
2922
takes_options = [Option('long', 'show help on all commands')]
1264
2923
takes_args = ['topic?']
1265
aliases = ['?']
2924
aliases = ['?', '--help', '-?', '-h']
1266
2925
2926
@display_command
1267
2927
def run(self, topic=None, long=False):
1268
import help
2928
import bzrlib.help
1269
2929
if topic is None and long:
1270
2930
topic = "commands"
1271
help.help(topic)
2931
bzrlib.help.help(topic)
1272
2932
1273
2933
1274
2934
class cmd_shell_complete(Command):
1275
2935
"""Show appropriate completions for context.
1276
2936
1277
For a list of all available commands, say 'bzr shell-complete'."""
2937
For a list of all available commands, say 'bzr shell-complete'.
2938
"""
1278
2939
takes_args = ['context?']
1279
2940
aliases = ['s-c']
1280
2941
hidden = True
1281
2942
2943
@display_command
1282
2944
def run(self, context=None):
1283
2945
import shellcomplete
1284
2946
shellcomplete.shellcomplete(context)
1285
2947
1286
2948
2949
class cmd_fetch(Command):
2950
"""Copy in history from another branch but don't merge it.
2951
2952
This is an internal method used for pull and merge.
2953
"""
2954
hidden = True
2955
takes_args = ['from_branch', 'to_branch']
2956
def run(self, from_branch, to_branch):
2957
from bzrlib.fetch import Fetcher
2958
from_b = Branch.open(from_branch)
2959
to_b = Branch.open(to_branch)
2960
Fetcher(to_b, from_b)
2961
2962
1287
2963
class cmd_missing(Command):
1288
"""What is missing in this branch relative to other branch.
2964
"""Show unmerged/unpulled revisions between two branches.
2965
2966
OTHER_BRANCH may be local or remote.
1289
2967
"""
1290
takes_args = ['remote?']
1291
aliases = ['mis', 'miss']
1292
# We don't have to add quiet to the list, because
1293
# unknown options are parsed as booleans
1294
takes_options = ['verbose', 'quiet']
1295
1296
def run(self, remote=None, verbose=False, quiet=False):
1297
from bzrlib.errors import BzrCommandError
1298
from bzrlib.missing import show_missing
1299
1300
if verbose and quiet:
1301
raise BzrCommandError('Cannot pass both quiet and verbose')
1302
1303
b = find_branch('.')
1304
parent = b.get_parent()
1305
if remote is None:
1306
if parent is None:
1307
raise BzrCommandError("No missing location known or specified.")
1308
else:
1309
if not quiet:
1310
print "Using last location: %s" % parent
1311
remote = parent
1312
elif parent is None:
1313
# We only update x-pull if it did not exist, missing should not change the parent
1314
b.controlfile('x-pull', 'wb').write(remote + '\n')
1315
br_remote = find_branch(remote)
1316
1317
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1318
2968
2969
_see_also = ['merge', 'pull']
2970
takes_args = ['other_branch?']
2971
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2972
Option('mine-only',
2973
'Display changes in the local branch only'),
2974
Option('this' , 'same as --mine-only'),
2975
Option('theirs-only',
2976
'Display changes in the remote branch only'),
2977
Option('other', 'same as --theirs-only'),
2978
'log-format',
2979
'show-ids',
2980
'verbose'
2981
]
2982
encoding_type = 'replace'
2983
2984
@display_command
2985
def run(self, other_branch=None, reverse=False, mine_only=False,
2986
theirs_only=False, log_format=None, long=False, short=False, line=False,
2987
show_ids=False, verbose=False, this=False, other=False):
2988
from bzrlib.missing import find_unmerged, iter_log_revisions
2989
from bzrlib.log import log_formatter
2990
2991
if this:
2992
mine_only = this
2993
if other:
2994
theirs_only = other
2995
2996
local_branch = Branch.open_containing(u".")[0]
2997
parent = local_branch.get_parent()
2998
if other_branch is None:
2999
other_branch = parent
3000
if other_branch is None:
3001
raise errors.BzrCommandError("No peer location known or specified.")
3002
display_url = urlutils.unescape_for_display(parent,
3003
self.outf.encoding)
3004
print "Using last location: " + display_url
3005
3006
remote_branch = Branch.open(other_branch)
3007
if remote_branch.base == local_branch.base:
3008
remote_branch = local_branch
3009
local_branch.lock_read()
3010
try:
3011
remote_branch.lock_read()
3012
try:
3013
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
3014
if (log_format is None):
3015
log_format = log.log_formatter_registry.get_default(
3016
local_branch)
3017
lf = log_format(to_file=self.outf,
3018
show_ids=show_ids,
3019
show_timezone='original')
3020
if reverse is False:
3021
local_extra.reverse()
3022
remote_extra.reverse()
3023
if local_extra and not theirs_only:
3024
print "You have %d extra revision(s):" % len(local_extra)
3025
for revision in iter_log_revisions(local_extra,
3026
local_branch.repository,
3027
verbose):
3028
lf.log_revision(revision)
3029
printed_local = True
3030
else:
3031
printed_local = False
3032
if remote_extra and not mine_only:
3033
if printed_local is True:
3034
print "\n\n"
3035
print "You are missing %d revision(s):" % len(remote_extra)
3036
for revision in iter_log_revisions(remote_extra,
3037
remote_branch.repository,
3038
verbose):
3039
lf.log_revision(revision)
3040
if not remote_extra and not local_extra:
3041
status_code = 0
3042
print "Branches are up to date."
3043
else:
3044
status_code = 1
3045
finally:
3046
remote_branch.unlock()
3047
finally:
3048
local_branch.unlock()
3049
if not status_code and parent is None and other_branch is not None:
3050
local_branch.lock_write()
3051
try:
3052
# handle race conditions - a parent might be set while we run.
3053
if local_branch.get_parent() is None:
3054
local_branch.set_parent(remote_branch.base)
3055
finally:
3056
local_branch.unlock()
3057
return status_code
1319
3058
1320
3059
1321
3060
class cmd_plugins(Command):
1322
3061
"""List plugins"""
1323
3062
hidden = True
3063
@display_command
1324
3064
def run(self):
1325
3065
import bzrlib.plugin
1326
3066
from inspect import getdoc
1327
for plugin in bzrlib.plugin.all_plugins:
1328
if hasattr(plugin, '__path__'):
3067
for name, plugin in bzrlib.plugin.all_plugins().items():
3068
if getattr(plugin, '__path__', None) is not None:
1329
3069
print plugin.__path__[0]
1330
elif hasattr(plugin, '__file__'):
3070
elif getattr(plugin, '__file__', None) is not None:
1331
3071
print plugin.__file__
1332
3072
else:
1333
print `plugin`
3073
print repr(plugin)
1334
3074
1335
3075
d = getdoc(plugin)
1336
3076
if d:
1337
3077
print '\t', d.split('\n')[0]
1338
3078
1339
3079
3080
class cmd_testament(Command):
3081
"""Show testament (signing-form) of a revision."""
3082
takes_options = ['revision',
3083
Option('long', help='Produce long-format testament'),
3084
Option('strict', help='Produce a strict-format'
3085
' testament')]
3086
takes_args = ['branch?']
3087
@display_command
3088
def run(self, branch=u'.', revision=None, long=False, strict=False):
3089
from bzrlib.testament import Testament, StrictTestament
3090
if strict is True:
3091
testament_class = StrictTestament
3092
else:
3093
testament_class = Testament
3094
b = WorkingTree.open_containing(branch)[0].branch
3095
b.lock_read()
3096
try:
3097
if revision is None:
3098
rev_id = b.last_revision()
3099
else:
3100
rev_id = revision[0].in_history(b).rev_id
3101
t = testament_class.from_revision(b.repository, rev_id)
3102
if long:
3103
sys.stdout.writelines(t.as_text_lines())
3104
else:
3105
sys.stdout.write(t.as_short_text())
3106
finally:
3107
b.unlock()
3108
3109
3110
class cmd_annotate(Command):
3111
"""Show the origin of each line in a file.
3112
3113
This prints out the given file with an annotation on the left side
3114
indicating which revision, author and date introduced the change.
3115
3116
If the origin is the same for a run of consecutive lines, it is
3117
shown only at the top, unless the --all option is given.
3118
"""
3119
# TODO: annotate directories; showing when each file was last changed
3120
# TODO: if the working copy is modified, show annotations on that
3121
# with new uncommitted lines marked
3122
aliases = ['ann', 'blame', 'praise']
3123
takes_args = ['filename']
3124
takes_options = [Option('all', help='show annotations on all lines'),
3125
Option('long', help='show date in annotations'),
3126
'revision',
3127
'show-ids',
3128
]
3129
3130
@display_command
3131
def run(self, filename, all=False, long=False, revision=None,
3132
show_ids=False):
3133
from bzrlib.annotate import annotate_file
3134
tree, relpath = WorkingTree.open_containing(filename)
3135
branch = tree.branch
3136
branch.lock_read()
3137
try:
3138
if revision is None:
3139
revision_id = branch.last_revision()
3140
elif len(revision) != 1:
3141
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
3142
else:
3143
revision_id = revision[0].in_history(branch).rev_id
3144
file_id = tree.path2id(relpath)
3145
tree = branch.repository.revision_tree(revision_id)
3146
file_version = tree.inventory[file_id].revision
3147
annotate_file(branch, file_version, file_id, long, all, sys.stdout,
3148
show_ids=show_ids)
3149
finally:
3150
branch.unlock()
3151
3152
3153
class cmd_re_sign(Command):
3154
"""Create a digital signature for an existing revision."""
3155
# TODO be able to replace existing ones.
3156
3157
hidden = True # is this right ?
3158
takes_args = ['revision_id*']
3159
takes_options = ['revision']
3160
3161
def run(self, revision_id_list=None, revision=None):
3162
import bzrlib.gpg as gpg
3163
if revision_id_list is not None and revision is not None:
3164
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
3165
if revision_id_list is None and revision is None:
3166
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
3167
b = WorkingTree.open_containing(u'.')[0].branch
3168
gpg_strategy = gpg.GPGStrategy(b.get_config())
3169
if revision_id_list is not None:
3170
for revision_id in revision_id_list:
3171
b.repository.sign_revision(revision_id, gpg_strategy)
3172
elif revision is not None:
3173
if len(revision) == 1:
3174
revno, rev_id = revision[0].in_history(b)
3175
b.repository.sign_revision(rev_id, gpg_strategy)
3176
elif len(revision) == 2:
3177
# are they both on rh- if so we can walk between them
3178
# might be nice to have a range helper for arbitrary
3179
# revision paths. hmm.
3180
from_revno, from_revid = revision[0].in_history(b)
3181
to_revno, to_revid = revision[1].in_history(b)
3182
if to_revid is None:
3183
to_revno = b.revno()
3184
if from_revno is None or to_revno is None:
3185
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
3186
for revno in range(from_revno, to_revno + 1):
3187
b.repository.sign_revision(b.get_rev_id(revno),
3188
gpg_strategy)
3189
else:
3190
raise errors.BzrCommandError('Please supply either one revision, or a range.')
3191
3192
3193
class cmd_bind(Command):
3194
"""Convert the current branch into a checkout of the supplied branch.
3195
3196
Once converted into a checkout, commits must succeed on the master branch
3197
before they will be applied to the local branch.
3198
"""
3199
3200
_see_also = ['checkouts', 'unbind']
3201
takes_args = ['location?']
3202
takes_options = []
3203
3204
def run(self, location=None):
3205
b, relpath = Branch.open_containing(u'.')
3206
if location is None:
3207
try:
3208
location = b.get_old_bound_location()
3209
except errors.UpgradeRequired:
3210
raise errors.BzrCommandError('No location supplied. '
3211
'This format does not remember old locations.')
3212
else:
3213
if location is None:
3214
raise errors.BzrCommandError('No location supplied and no '
3215
'previous location known')
3216
b_other = Branch.open(location)
3217
try:
3218
b.bind(b_other)
3219
except errors.DivergedBranches:
3220
raise errors.BzrCommandError('These branches have diverged.'
3221
' Try merging, and then bind again.')
3222
3223
3224
class cmd_unbind(Command):
3225
"""Convert the current checkout into a regular branch.
3226
3227
After unbinding, the local branch is considered independent and subsequent
3228
commits will be local only.
3229
"""
3230
3231
_see_also = ['checkouts', 'bind']
3232
takes_args = []
3233
takes_options = []
3234
3235
def run(self):
3236
b, relpath = Branch.open_containing(u'.')
3237
if not b.unbind():
3238
raise errors.BzrCommandError('Local branch is not bound')
3239
3240
3241
class cmd_uncommit(Command):
3242
"""Remove the last committed revision.
3243
3244
--verbose will print out what is being removed.
3245
--dry-run will go through all the motions, but not actually
3246
remove anything.
3247
3248
In the future, uncommit will create a revision bundle, which can then
3249
be re-applied.
3250
"""
3251
3252
# TODO: jam 20060108 Add an option to allow uncommit to remove
3253
# unreferenced information in 'branch-as-repository' branches.
3254
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
3255
# information in shared branches as well.
3256
_see_also = ['commit']
3257
takes_options = ['verbose', 'revision',
3258
Option('dry-run', help='Don\'t actually make changes'),
3259
Option('force', help='Say yes to all questions.')]
3260
takes_args = ['location?']
3261
aliases = []
3262
3263
def run(self, location=None,
3264
dry_run=False, verbose=False,
3265
revision=None, force=False):
3266
from bzrlib.log import log_formatter, show_log
3267
import sys
3268
from bzrlib.uncommit import uncommit
3269
3270
if location is None:
3271
location = u'.'
3272
control, relpath = bzrdir.BzrDir.open_containing(location)
3273
try:
3274
tree = control.open_workingtree()
3275
b = tree.branch
3276
except (errors.NoWorkingTree, errors.NotLocalUrl):
3277
tree = None
3278
b = control.open_branch()
3279
3280
rev_id = None
3281
if revision is None:
3282
revno = b.revno()
3283
else:
3284
# 'bzr uncommit -r 10' actually means uncommit
3285
# so that the final tree is at revno 10.
3286
# but bzrlib.uncommit.uncommit() actually uncommits
3287
# the revisions that are supplied.
3288
# So we need to offset it by one
3289
revno = revision[0].in_history(b).revno+1
3290
3291
if revno <= b.revno():
3292
rev_id = b.get_rev_id(revno)
3293
if rev_id is None:
3294
self.outf.write('No revisions to uncommit.\n')
3295
return 1
3296
3297
lf = log_formatter('short',
3298
to_file=self.outf,
3299
show_timezone='original')
3300
3301
show_log(b,
3302
lf,
3303
verbose=False,
3304
direction='forward',
3305
start_revision=revno,
3306
end_revision=b.revno())
3307
3308
if dry_run:
3309
print 'Dry-run, pretending to remove the above revisions.'
3310
if not force:
3311
val = raw_input('Press <enter> to continue')
3312
else:
3313
print 'The above revision(s) will be removed.'
3314
if not force:
3315
val = raw_input('Are you sure [y/N]? ')
3316
if val.lower() not in ('y', 'yes'):
3317
print 'Canceled'
3318
return 0
3319
3320
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
3321
revno=revno)
3322
3323
3324
class cmd_break_lock(Command):
3325
"""Break a dead lock on a repository, branch or working directory.
3326
3327
CAUTION: Locks should only be broken when you are sure that the process
3328
holding the lock has been stopped.
3329
3330
You can get information on what locks are open via the 'bzr info' command.
3331
3332
example:
3333
bzr break-lock
3334
"""
3335
takes_args = ['location?']
3336
3337
def run(self, location=None, show=False):
3338
if location is None:
3339
location = u'.'
3340
control, relpath = bzrdir.BzrDir.open_containing(location)
3341
try:
3342
control.break_lock()
3343
except NotImplementedError:
3344
pass
3345
3346
3347
class cmd_wait_until_signalled(Command):
3348
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
3349
3350
This just prints a line to signal when it is ready, then blocks on stdin.
3351
"""
3352
3353
hidden = True
3354
3355
def run(self):
3356
sys.stdout.write("running\n")
3357
sys.stdout.flush()
3358
sys.stdin.readline()
3359
3360
3361
class cmd_serve(Command):
3362
"""Run the bzr server."""
3363
3364
aliases = ['server']
3365
3366
takes_options = [
3367
Option('inet',
3368
help='serve on stdin/out for use from inetd or sshd'),
3369
Option('port',
3370
help='listen for connections on nominated port of the form '
3371
'[hostname:]portnumber. Passing 0 as the port number will '
3372
'result in a dynamically allocated port. Default port is '
3373
'4155.',
3374
type=str),
3375
Option('directory',
3376
help='serve contents of directory',
3377
type=unicode),
3378
Option('allow-writes',
3379
help='By default the server is a readonly server. Supplying '
3380
'--allow-writes enables write access to the contents of '
3381
'the served directory and below. '
3382
),
3383
]
3384
3385
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3386
from bzrlib.smart import medium, server
3387
from bzrlib.transport import get_transport
3388
from bzrlib.transport.chroot import ChrootServer
3389
from bzrlib.transport.remote import BZR_DEFAULT_PORT, BZR_DEFAULT_INTERFACE
3390
if directory is None:
3391
directory = os.getcwd()
3392
url = urlutils.local_path_to_url(directory)
3393
if not allow_writes:
3394
url = 'readonly+' + url
3395
chroot_server = ChrootServer(get_transport(url))
3396
chroot_server.setUp()
3397
t = get_transport(chroot_server.get_url())
3398
if inet:
3399
smart_server = medium.SmartServerPipeStreamMedium(
3400
sys.stdin, sys.stdout, t)
3401
else:
3402
host = BZR_DEFAULT_INTERFACE
3403
if port is None:
3404
port = BZR_DEFAULT_PORT
3405
else:
3406
if ':' in port:
3407
host, port = port.split(':')
3408
port = int(port)
3409
smart_server = server.SmartTCPServer(t, host=host, port=port)
3410
print 'listening on port: ', smart_server.port
3411
sys.stdout.flush()
3412
# for the duration of this server, no UI output is permitted.
3413
# note that this may cause problems with blackbox tests. This should
3414
# be changed with care though, as we dont want to use bandwidth sending
3415
# progress over stderr to smart server clients!
3416
old_factory = ui.ui_factory
3417
try:
3418
ui.ui_factory = ui.SilentUIFactory()
3419
smart_server.serve()
3420
finally:
3421
ui.ui_factory = old_factory
3422
3423
3424
class cmd_join(Command):
3425
"""Combine a subtree into its containing tree.
3426
3427
This command is for experimental use only. It requires the target tree
3428
to be in dirstate-with-subtree format, which cannot be converted into
3429
earlier formats.
3430
3431
The TREE argument should be an independent tree, inside another tree, but
3432
not part of it. (Such trees can be produced by "bzr split", but also by
3433
running "bzr branch" with the target inside a tree.)
3434
3435
The result is a combined tree, with the subtree no longer an independant
3436
part. This is marked as a merge of the subtree into the containing tree,
3437
and all history is preserved.
3438
3439
If --reference is specified, the subtree retains its independence. It can
3440
be branched by itself, and can be part of multiple projects at the same
3441
time. But operations performed in the containing tree, such as commit
3442
and merge, will recurse into the subtree.
3443
"""
3444
3445
_see_also = ['split']
3446
takes_args = ['tree']
3447
takes_options = [Option('reference', 'join by reference')]
3448
hidden = True
3449
3450
def run(self, tree, reference=False):
3451
sub_tree = WorkingTree.open(tree)
3452
parent_dir = osutils.dirname(sub_tree.basedir)
3453
containing_tree = WorkingTree.open_containing(parent_dir)[0]
3454
repo = containing_tree.branch.repository
3455
if not repo.supports_rich_root():
3456
raise errors.BzrCommandError(
3457
"Can't join trees because %s doesn't support rich root data.\n"
3458
"You can use bzr upgrade on the repository."
3459
% (repo,))
3460
if reference:
3461
try:
3462
containing_tree.add_reference(sub_tree)
3463
except errors.BadReferenceTarget, e:
3464
# XXX: Would be better to just raise a nicely printable
3465
# exception from the real origin. Also below. mbp 20070306
3466
raise errors.BzrCommandError("Cannot join %s. %s" %
3467
(tree, e.reason))
3468
else:
3469
try:
3470
containing_tree.subsume(sub_tree)
3471
except errors.BadSubsumeSource, e:
3472
raise errors.BzrCommandError("Cannot join %s. %s" %
3473
(tree, e.reason))
3474
3475
3476
class cmd_split(Command):
3477
"""Split a tree into two trees.
3478
3479
This command is for experimental use only. It requires the target tree
3480
to be in dirstate-with-subtree format, which cannot be converted into
3481
earlier formats.
3482
3483
The TREE argument should be a subdirectory of a working tree. That
3484
subdirectory will be converted into an independent tree, with its own
3485
branch. Commits in the top-level tree will not apply to the new subtree.
3486
If you want that behavior, do "bzr join --reference TREE".
3487
"""
3488
3489
_see_also = ['join']
3490
takes_args = ['tree']
3491
3492
hidden = True
3493
3494
def run(self, tree):
3495
containing_tree, subdir = WorkingTree.open_containing(tree)
3496
sub_id = containing_tree.path2id(subdir)
3497
if sub_id is None:
3498
raise errors.NotVersionedError(subdir)
3499
try:
3500
containing_tree.extract(sub_id)
3501
except errors.RootNotRich:
3502
raise errors.UpgradeRequired(containing_tree.branch.base)
3503
3504
3505
3506
class cmd_merge_directive(Command):
3507
"""Generate a merge directive for auto-merge tools.
3508
3509
A directive requests a merge to be performed, and also provides all the
3510
information necessary to do so. This means it must either include a
3511
revision bundle, or the location of a branch containing the desired
3512
revision.
3513
3514
A submit branch (the location to merge into) must be supplied the first
3515
time the command is issued. After it has been supplied once, it will
3516
be remembered as the default.
3517
3518
A public branch is optional if a revision bundle is supplied, but required
3519
if --diff or --plain is specified. It will be remembered as the default
3520
after the first use.
3521
"""
3522
3523
takes_args = ['submit_branch?', 'public_branch?']
3524
3525
takes_options = [
3526
RegistryOption.from_kwargs('patch-type',
3527
'The type of patch to include in the directive',
3528
title='Patch type', value_switches=True, enum_switch=False,
3529
bundle='Bazaar revision bundle (default)',
3530
diff='Normal unified diff',
3531
plain='No patch, just directive'),
3532
Option('sign', help='GPG-sign the directive'), 'revision',
3533
Option('mail-to', type=str,
3534
help='Instead of printing the directive, email to this address'),
3535
Option('message', type=str, short_name='m',
3536
help='Message to use when committing this merge')
3537
]
3538
3539
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
3540
sign=False, revision=None, mail_to=None, message=None):
3541
from bzrlib.revision import ensure_null, NULL_REVISION
3542
if patch_type == 'plain':
3543
patch_type = None
3544
branch = Branch.open('.')
3545
stored_submit_branch = branch.get_submit_branch()
3546
if submit_branch is None:
3547
submit_branch = stored_submit_branch
3548
else:
3549
if stored_submit_branch is None:
3550
branch.set_submit_branch(submit_branch)
3551
if submit_branch is None:
3552
submit_branch = branch.get_parent()
3553
if submit_branch is None:
3554
raise errors.BzrCommandError('No submit branch specified or known')
3555
3556
stored_public_branch = branch.get_public_branch()
3557
if public_branch is None:
3558
public_branch = stored_public_branch
3559
elif stored_public_branch is None:
3560
branch.set_public_branch(public_branch)
3561
if patch_type != "bundle" and public_branch is None:
3562
raise errors.BzrCommandError('No public branch specified or'
3563
' known')
3564
if revision is not None:
3565
if len(revision) != 1:
3566
raise errors.BzrCommandError('bzr merge-directive takes '
3567
'exactly one revision identifier')
3568
else:
3569
revision_id = revision[0].in_history(branch).rev_id
3570
else:
3571
revision_id = branch.last_revision()
3572
revision_id = ensure_null(revision_id)
3573
if revision_id == NULL_REVISION:
3574
raise errors.BzrCommandError('No revisions to bundle.')
3575
directive = merge_directive.MergeDirective.from_objects(
3576
branch.repository, revision_id, time.time(),
3577
osutils.local_time_offset(), submit_branch,
3578
public_branch=public_branch, patch_type=patch_type,
3579
message=message)
3580
if mail_to is None:
3581
if sign:
3582
self.outf.write(directive.to_signed(branch))
3583
else:
3584
self.outf.writelines(directive.to_lines())
3585
else:
3586
message = directive.to_email(mail_to, branch, sign)
3587
s = smtplib.SMTP()
3588
server = branch.get_config().get_user_option('smtp_server')
3589
if not server:
3590
server = 'localhost'
3591
s.connect(server)
3592
s.sendmail(message['From'], message['To'], message.as_string())
3593
3594
3595
class cmd_tag(Command):
3596
"""Create a tag naming a revision.
3597
3598
Tags give human-meaningful names to revisions. Commands that take a -r
3599
(--revision) option can be given -rtag:X, where X is any previously
3600
created tag.
3601
3602
Tags are stored in the branch. Tags are copied from one branch to another
3603
along when you branch, push, pull or merge.
3604
3605
It is an error to give a tag name that already exists unless you pass
3606
--force, in which case the tag is moved to point to the new revision.
3607
"""
3608
3609
_see_also = ['commit', 'tags']
3610
takes_args = ['tag_name']
3611
takes_options = [
3612
Option('delete',
3613
help='Delete this tag rather than placing it.',
3614
),
3615
Option('directory',
3616
help='Branch in which to place the tag.',
3617
short_name='d',
3618
type=unicode,
3619
),
3620
Option('force',
3621
help='Replace existing tags',
3622
),
3623
'revision',
3624
]
3625
3626
def run(self, tag_name,
3627
delete=None,
3628
directory='.',
3629
force=None,
3630
revision=None,
3631
):
3632
branch, relpath = Branch.open_containing(directory)
3633
branch.lock_write()
3634
try:
3635
if delete:
3636
branch.tags.delete_tag(tag_name)
3637
self.outf.write('Deleted tag %s.\n' % tag_name)
3638
else:
3639
if revision:
3640
if len(revision) != 1:
3641
raise errors.BzrCommandError(
3642
"Tags can only be placed on a single revision, "
3643
"not on a range")
3644
revision_id = revision[0].in_history(branch).rev_id
3645
else:
3646
revision_id = branch.last_revision()
3647
if (not force) and branch.tags.has_tag(tag_name):
3648
raise errors.TagAlreadyExists(tag_name)
3649
branch.tags.set_tag(tag_name, revision_id)
3650
self.outf.write('Created tag %s.\n' % tag_name)
3651
finally:
3652
branch.unlock()
3653
3654
3655
class cmd_tags(Command):
3656
"""List tags.
3657
3658
This tag shows a table of tag names and the revisions they reference.
3659
"""
3660
3661
_see_also = ['tag']
3662
takes_options = [
3663
Option('directory',
3664
help='Branch whose tags should be displayed',
3665
short_name='d',
3666
type=unicode,
3667
),
3668
]
3669
3670
@display_command
3671
def run(self,
3672
directory='.',
3673
):
3674
branch, relpath = Branch.open_containing(directory)
3675
for tag_name, target in sorted(branch.tags.get_tag_dict().items()):
3676
self.outf.write('%-20s %s\n' % (tag_name, target))
3677
3678
3679
# command-line interpretation helper for merge-related commands
3680
def _merge_helper(other_revision, base_revision,
3681
check_clean=True, ignore_zero=False,
3682
this_dir=None, backup_files=False,
3683
merge_type=None,
3684
file_list=None, show_base=False, reprocess=False,
3685
pull=False,
3686
pb=DummyProgress(),
3687
change_reporter=None,
3688
other_rev_id=None):
3689
"""Merge changes into a tree.
3690
3691
base_revision
3692
list(path, revno) Base for three-way merge.
3693
If [None, None] then a base will be automatically determined.
3694
other_revision
3695
list(path, revno) Other revision for three-way merge.
3696
this_dir
3697
Directory to merge changes into; '.' by default.
3698
check_clean
3699
If true, this_dir must have no uncommitted changes before the
3700
merge begins.
3701
ignore_zero - If true, suppress the "zero conflicts" message when
3702
there are no conflicts; should be set when doing something we expect
3703
to complete perfectly.
3704
file_list - If supplied, merge only changes to selected files.
3705
3706
All available ancestors of other_revision and base_revision are
3707
automatically pulled into the branch.
3708
3709
The revno may be -1 to indicate the last revision on the branch, which is
3710
the typical case.
3711
3712
This function is intended for use from the command line; programmatic
3713
clients might prefer to call merge.merge_inner(), which has less magic
3714
behavior.
3715
"""
3716
# Loading it late, so that we don't always have to import bzrlib.merge
3717
if merge_type is None:
3718
merge_type = _mod_merge.Merge3Merger
3719
if this_dir is None:
3720
this_dir = u'.'
3721
this_tree = WorkingTree.open_containing(this_dir)[0]
3722
if show_base and not merge_type is _mod_merge.Merge3Merger:
3723
raise errors.BzrCommandError("Show-base is not supported for this merge"
3724
" type. %s" % merge_type)
3725
if reprocess and not merge_type.supports_reprocess:
3726
raise errors.BzrCommandError("Conflict reduction is not supported for merge"
3727
" type %s." % merge_type)
3728
if reprocess and show_base:
3729
raise errors.BzrCommandError("Cannot do conflict reduction and show base.")
3730
# TODO: jam 20070226 We should really lock these trees earlier. However, we
3731
# only want to take out a lock_tree_write() if we don't have to pull
3732
# any ancestry. But merge might fetch ancestry in the middle, in
3733
# which case we would need a lock_write().
3734
# Because we cannot upgrade locks, for now we live with the fact that
3735
# the tree will be locked multiple times during a merge. (Maybe
3736
# read-only some of the time, but it means things will get read
3737
# multiple times.)
3738
try:
3739
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
3740
pb=pb, change_reporter=change_reporter)
3741
merger.pp = ProgressPhase("Merge phase", 5, pb)
3742
merger.pp.next_phase()
3743
merger.check_basis(check_clean)
3744
if other_rev_id is not None:
3745
merger.set_other_revision(other_rev_id, this_tree.branch)
3746
else:
3747
merger.set_other(other_revision)
3748
merger.pp.next_phase()
3749
merger.set_base(base_revision)
3750
if merger.base_rev_id == merger.other_rev_id:
3751
note('Nothing to do.')
3752
return 0
3753
if file_list is None:
3754
if pull and merger.base_rev_id == merger.this_rev_id:
3755
# FIXME: deduplicate with pull
3756
result = merger.this_tree.pull(merger.this_branch,
3757
False, merger.other_rev_id)
3758
if result.old_revid == result.new_revid:
3759
note('No revisions to pull.')
3760
else:
3761
note('Now on revision %d.' % result.new_revno)
3762
return 0
3763
merger.backup_files = backup_files
3764
merger.merge_type = merge_type
3765
merger.set_interesting_files(file_list)
3766
merger.show_base = show_base
3767
merger.reprocess = reprocess
3768
conflicts = merger.do_merge()
3769
if file_list is None:
3770
merger.set_pending()
3771
finally:
3772
pb.clear()
3773
return conflicts
3774
3775
3776
def _create_prefix(cur_transport):
3777
needed = [cur_transport]
3778
# Recurse upwards until we can create a directory successfully
3779
while True:
3780
new_transport = cur_transport.clone('..')
3781
if new_transport.base == cur_transport.base:
3782
raise errors.BzrCommandError("Failed to create path"
3783
" prefix for %s."
3784
% location)
3785
try:
3786
new_transport.mkdir('.')
3787
except errors.NoSuchFile:
3788
needed.append(new_transport)
3789
cur_transport = new_transport
3790
else:
3791
break
3792
3793
# Now we only need to create child directories
3794
while needed:
3795
cur_transport = needed.pop()
3796
cur_transport.ensure_base()
3797
3798
# Compatibility
3799
merge = _merge_helper
3800
3801
3802
# these get imported and then picked up by the scan for cmd_*
3803
# TODO: Some more consistent way to split command definitions across files;
3804
# we do need to load at least some information about them to know of
3805
# aliases. ideally we would avoid loading the implementation until the
3806
# details were needed.
3807
from bzrlib.cmd_version_info import cmd_version_info
3808
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
3809
from bzrlib.bundle.commands import (
3810
cmd_bundle_revisions,
3811
cmd_bundle_info,
3812
)
3813
from bzrlib.sign_my_commits import cmd_sign_my_commits
3814
from bzrlib.weave_commands import cmd_versionedfile_list, cmd_weave_join, \
3815
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1