« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1711.2.23
- compare with another revision
- download diff
- download tarball
- view history from revision 1711.2.23
- Committer: John Arbash Meinel
- Date: 2006-05-29 00:58:36 UTC
- mto: (1753.1.3 add) (1711.7.2 win32) (1946.2.6 reduce-knit-churn)
- mto: This revision was merged to the branch mainline in revision 1733.
- Revision ID: john@arbash-meinel.com-20060529005836-edcca3f46afe0d07
Late bind to PatienceSequenceMatcher in merge3.py
- files added:
- NEWS.developers
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/util/urlgrabber
- files removed:
- COPYING.txt
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/serializer
- bzrlib/help_topics
- bzrlib/help_topics/en
- bzrlib/repofmt
- bzrlib/smart
- bzrlib/tests/commands
- bzrlib/tests/intertree_implementations
- bzrlib/tests/inventory_implementations
- bzrlib/tests/per_lock
- bzrlib/tests/per_repository_reference
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/transport/ftp
- bzrlib/util/tests
- bzrlib/version_info_formats
- doc/developers
- doc/en
- doc/en/admin-guide
- doc/en/developer-guide
- doc/en/mini-tutorial
- doc/en/quick-reference
- doc/en/release-notes
- doc/en/tutorials
- doc/en/user-guide
- doc/en/user-guide/images
- doc/en/user-reference
- doc/es
- doc/es/guia-desarrollador
- doc/es/guia-usuario
- doc/es/mini-tutorial
- doc/es/notas-version
- doc/es/referencia
- doc/es/referencia-rapida
- man1
- tools/packaging
- tools/win32
- files renamed:
- doc/developers/HACKING.txt => HACKING
- bzrlib/deprecated_graph.py => bzrlib/graph.py
- bzrlib/_patiencediff_py.py => bzrlib/patiencediff.py
- bzrlib/tests/http_utils.py => bzrlib/tests/HTTPTestUtil.py
- bzrlib/tests/test_commands.py => bzrlib/tests/test_command.py
- bzrlib/tests/test_deprecated_graph.py => bzrlib/tests/test_graph.py
- bzrlib/tests/test_revisionspec.py => bzrlib/tests/test_revisionnamespaces.py
- bzrlib/tests/repository_implementations/test_revision.py => bzrlib/tests/test_revprops.py
- bzrlib/transport/ftp/__init__.py => bzrlib/transport/ftp.py
- bzrlib/win32utils.py => bzrlib/win32console.py
- bzrlib/xml8.py => bzrlib/xml5.py
- bzrlib/help_topics/en/configuration.txt => doc/configuration.txt
- doc/en/user-guide/plugins.txt => doc/plugins.txt
- doc/en/user-guide/setting_up_email.txt => doc/setting_up_email.txt
- doc/en/user-guide/specifying_revisions.txt => doc/specifying_revisions.txt
- doc/en/tutorials/tutorial.txt => doc/tutorial.txt
- doc/en/user-guide/using_aliases.txt => doc/using_aliases.txt
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006, 2007, 2008 Canonical Ltd
2
#
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
2
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
#
7
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
12
#
12
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
"""builtin bzr commands"""
18
18
19
20
import errno
19
21
import os
20
from StringIO import StringIO
21
22
from bzrlib.lazy_import import lazy_import
23
lazy_import(globals(), """
24
import codecs
25
22
import sys
26
import time
27
23
28
24
import bzrlib
29
from bzrlib import (
30
bugtracker,
31
bundle,
32
bzrdir,
33
delta,
34
config,
35
errors,
36
globbing,
37
ignores,
38
log,
39
merge as _mod_merge,
40
merge_directive,
41
osutils,
42
reconfigure,
43
revision as _mod_revision,
44
symbol_versioning,
45
transport,
46
tree as _mod_tree,
47
ui,
48
urlutils,
49
)
25
import bzrlib.branch
50
26
from bzrlib.branch import Branch
51
from bzrlib.conflicts import ConflictList
27
import bzrlib.bzrdir as bzrdir
28
from bzrlib.commands import Command, display_command
29
import bzrlib.errors as errors
30
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
31
NotBranchError, DivergedBranches, NotConflicted,
32
NoSuchFile, NoWorkingTree, FileInWrongBranch,
33
NotVersionedError)
34
from bzrlib.log import show_one_log
35
from bzrlib.merge import Merge3Merger
36
from bzrlib.option import Option
37
from bzrlib.progress import DummyProgress, ProgressPhase
38
from bzrlib.revision import common_ancestor
52
39
from bzrlib.revisionspec import RevisionSpec
53
from bzrlib.smtp_connection import SMTPConnection
40
import bzrlib.trace
41
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
42
from bzrlib.transport.local import LocalTransport
43
import bzrlib.ui
54
44
from bzrlib.workingtree import WorkingTree
55
""")
56
57
from bzrlib.commands import Command, display_command
58
from bzrlib.option import ListOption, Option, RegistryOption, custom_help
59
from bzrlib.trace import mutter, note, warning, is_quiet, info
60
45
61
46
62
47
def tree_files(file_list, default_branch=u'.'):
63
48
try:
64
49
return internal_tree_files(file_list, default_branch)
65
except errors.FileInWrongBranch, e:
66
raise errors.BzrCommandError("%s is not in the same branch as %s" %
67
(e.path, file_list[0]))
50
except FileInWrongBranch, e:
51
raise BzrCommandError("%s is not in the same branch as %s" %
52
(e.path, file_list[0]))
68
53
69
54
70
55
# XXX: Bad function name; should possibly also be a class method of
79
64
80
65
:param file_list: Filenames to convert.
81
66
82
:param default_branch: Fallback tree path to use if file_list is empty or
83
None.
67
:param default_branch: Fallback tree path to use if file_list is empty or None.
84
68
85
69
:return: workingtree, [relative_paths]
86
70
"""
87
71
if file_list is None or len(file_list) == 0:
88
72
return WorkingTree.open_containing(default_branch)[0], file_list
89
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
90
return tree, safe_relpath_files(tree, file_list)
91
92
93
def safe_relpath_files(tree, file_list):
94
"""Convert file_list into a list of relpaths in tree.
95
96
:param tree: A tree to operate on.
97
:param file_list: A list of user provided paths or None.
98
:return: A list of relative paths.
99
:raises errors.PathNotChild: When a provided path is in a different tree
100
than tree.
101
"""
102
if file_list is None:
103
return None
73
tree = WorkingTree.open_containing(file_list[0])[0]
104
74
new_list = []
105
75
for filename in file_list:
106
76
try:
107
new_list.append(tree.relpath(osutils.dereference_path(filename)))
77
new_list.append(tree.relpath(filename))
108
78
except errors.PathNotChild:
109
raise errors.FileInWrongBranch(tree.branch, filename)
110
return new_list
79
raise FileInWrongBranch(tree.branch, filename)
80
return tree, new_list
81
82
83
def get_format_type(typestring):
84
"""Parse and return a format specifier."""
85
if typestring == "weave":
86
return bzrdir.BzrDirFormat6()
87
if typestring == "default":
88
return bzrdir.BzrDirMetaFormat1()
89
if typestring == "metaweave":
90
format = bzrdir.BzrDirMetaFormat1()
91
format.repository_format = bzrlib.repository.RepositoryFormat7()
92
return format
93
if typestring == "knit":
94
format = bzrdir.BzrDirMetaFormat1()
95
format.repository_format = bzrlib.repository.RepositoryFormatKnit1()
96
return format
97
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
98
"metaweave and weave" % typestring
99
raise BzrCommandError(msg)
111
100
112
101
113
102
# TODO: Make sure no commands unconditionally use the working directory as a
137
126
modified
138
127
Text has changed since the previous revision.
139
128
140
kind changed
141
File kind has been changed (e.g. from file to directory).
129
unchanged
130
Nothing about this file has changed since the previous revision.
131
Only shown with --all.
142
132
143
133
unknown
144
134
Not versioned and not matching an ignore pattern.
145
135
146
To see ignored files use 'bzr ignored'. For details on the
136
To see ignored files use 'bzr ignored'. For details in the
147
137
changes to file texts, use 'bzr diff'.
148
149
Note that --short or -S gives status flags for each item, similar
150
to Subversion's status command. To get output similar to svn -q,
151
use bzr status -SV.
152
138
153
139
If no arguments are specified, the status of the entire working
154
140
directory is shown. Otherwise, only the status of the specified
162
148
# TODO: --no-recurse, --recurse options
163
149
164
150
takes_args = ['file*']
165
takes_options = ['show-ids', 'revision', 'change',
166
Option('short', help='Use short status indicators.',
167
short_name='S'),
168
Option('versioned', help='Only show versioned files.',
169
short_name='V'),
170
Option('no-pending', help='Don\'t show pending merges.',
171
),
172
]
151
takes_options = ['all', 'show-ids', 'revision']
173
152
aliases = ['st', 'stat']
174
175
encoding_type = 'replace'
176
_see_also = ['diff', 'revert', 'status-flags']
177
153
178
154
@display_command
179
def run(self, show_ids=False, file_list=None, revision=None, short=False,
180
versioned=False, no_pending=False):
155
def run(self, all=False, show_ids=False, file_list=None, revision=None):
156
tree, file_list = tree_files(file_list)
157
181
158
from bzrlib.status import show_tree_status
182
183
if revision and len(revision) > 2:
184
raise errors.BzrCommandError('bzr status --revision takes exactly'
185
' one or two revision specifiers')
186
187
tree, relfile_list = tree_files(file_list)
188
# Avoid asking for specific files when that is not needed.
189
if relfile_list == ['']:
190
relfile_list = None
191
# Don't disable pending merges for full trees other than '.'.
192
if file_list == ['.']:
193
no_pending = True
194
# A specific path within a tree was given.
195
elif relfile_list is not None:
196
no_pending = True
197
show_tree_status(tree, show_ids=show_ids,
198
specific_files=relfile_list, revision=revision,
199
to_file=self.outf, short=short, versioned=versioned,
200
show_pending=(not no_pending))
159
show_tree_status(tree, show_unchanged=all, show_ids=show_ids,
160
specific_files=file_list, revision=revision)
201
161
202
162
203
163
class cmd_cat_revision(Command):
210
170
hidden = True
211
171
takes_args = ['revision_id?']
212
172
takes_options = ['revision']
213
# cat-revision is more for frontends so should be exact
214
encoding = 'strict'
215
173
216
174
@display_command
217
175
def run(self, revision_id=None, revision=None):
176
218
177
if revision_id is not None and revision is not None:
219
raise errors.BzrCommandError('You can only supply one of'
220
' revision_id or --revision')
178
raise BzrCommandError('You can only supply one of revision_id or --revision')
221
179
if revision_id is None and revision is None:
222
raise errors.BzrCommandError('You must supply either'
223
' --revision or a revision_id')
180
raise BzrCommandError('You must supply either --revision or a revision_id')
224
181
b = WorkingTree.open_containing(u'.')[0].branch
225
226
# TODO: jam 20060112 should cat-revision always output utf-8?
227
182
if revision_id is not None:
228
revision_id = osutils.safe_revision_id(revision_id, warn=False)
229
try:
230
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
231
except errors.NoSuchRevision:
232
msg = "The repository %s contains no revision %s." % (b.repository.base,
233
revision_id)
234
raise errors.BzrCommandError(msg)
183
sys.stdout.write(b.repository.get_revision_xml(revision_id))
235
184
elif revision is not None:
236
185
for rev in revision:
237
186
if rev is None:
238
raise errors.BzrCommandError('You cannot specify a NULL'
239
' revision.')
240
rev_id = rev.as_revision_id(b)
241
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
187
raise BzrCommandError('You cannot specify a NULL revision.')
188
revno, rev_id = rev.in_history(b)
189
sys.stdout.write(b.repository.get_revision_xml(rev_id))
242
190
243
191
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
275
276
192
class cmd_revno(Command):
277
193
"""Show current revision number.
278
194
279
This is equal to the number of revisions on this branch.
280
"""
281
282
_see_also = ['info']
195
This is equal to the number of revisions on this branch."""
283
196
takes_args = ['location?']
284
285
197
@display_command
286
198
def run(self, location=u'.'):
287
self.outf.write(str(Branch.open_containing(location)[0].revno()))
288
self.outf.write('\n')
199
print Branch.open_containing(location)[0].revno()
289
200
290
201
291
202
class cmd_revision_info(Command):
294
205
hidden = True
295
206
takes_args = ['revision_info*']
296
207
takes_options = ['revision']
297
298
208
@display_command
299
209
def run(self, revision=None, revision_info_list=[]):
300
210
303
213
revs.extend(revision)
304
214
if revision_info_list is not None:
305
215
for rev in revision_info_list:
306
revs.append(RevisionSpec.from_string(rev))
307
308
b = Branch.open_containing(u'.')[0]
309
216
revs.append(RevisionSpec(rev))
310
217
if len(revs) == 0:
311
revs.append(RevisionSpec.from_string('-1'))
218
raise BzrCommandError('You must supply a revision identifier')
219
220
b = WorkingTree.open_containing(u'.')[0].branch
312
221
313
222
for rev in revs:
314
revision_id = rev.as_revision_id(b)
315
try:
316
revno = '%4d' % (b.revision_id_to_revno(revision_id))
317
except errors.NoSuchRevision:
318
dotted_map = b.get_revision_id_to_revno_map()
319
revno = '.'.join(str(i) for i in dotted_map[revision_id])
320
print '%s %s' % (revno, revision_id)
223
revinfo = rev.in_history(b)
224
if revinfo.revno is None:
225
print ' %s' % revinfo.rev_id
226
else:
227
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
321
228
322
229
323
230
class cmd_add(Command):
340
247
341
248
Adding a file whose parent directory is not versioned will
342
249
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
250
you should never need to explictly add a directory, they'll just
344
251
get added when you add a file in the directory.
345
252
346
253
--dry-run will show which files would be added, but not actually
347
254
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.
356
255
"""
357
256
takes_args = ['file*']
358
takes_options = [
359
Option('no-recurse',
360
help="Don't recursively add the contents of directories."),
361
Option('dry-run',
362
help="Show what would be done, but don't actually do anything."),
363
'verbose',
364
Option('file-ids-from',
365
type=unicode,
366
help='Lookup file ids from this tree.'),
367
]
368
encoding_type = 'replace'
369
_see_also = ['remove']
257
takes_options = ['no-recurse', 'dry-run', 'verbose']
370
258
371
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
372
file_ids_from=None):
259
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
373
260
import bzrlib.add
374
261
375
base_tree = None
376
if file_ids_from is not None:
377
try:
378
base_tree, base_path = WorkingTree.open_containing(
379
file_ids_from)
380
except errors.NoWorkingTree:
381
base_branch, base_path = Branch.open_containing(
382
file_ids_from)
383
base_tree = base_branch.basis_tree()
384
385
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
386
to_file=self.outf, should_print=(not is_quiet()))
262
if dry_run:
263
if is_quiet():
264
# This is pointless, but I'd rather not raise an error
265
action = bzrlib.add.add_action_null
266
else:
267
action = bzrlib.add.add_action_print
268
elif is_quiet():
269
action = bzrlib.add.add_action_add
387
270
else:
388
action = bzrlib.add.AddAction(to_file=self.outf,
389
should_print=(not is_quiet()))
271
action = bzrlib.add.add_action_add_and_print
390
272
391
if base_tree:
392
base_tree.lock_read()
393
try:
394
file_list = self._maybe_expand_globs(file_list)
395
if file_list:
396
tree = WorkingTree.open_containing(file_list[0])[0]
397
else:
398
tree = WorkingTree.open_containing(u'.')[0]
399
added, ignored = tree.smart_add(file_list, not
400
no_recurse, action=action, save=not dry_run)
401
finally:
402
if base_tree is not None:
403
base_tree.unlock()
273
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
274
action)
404
275
if len(ignored) > 0:
405
276
if verbose:
406
277
for glob in sorted(ignored.keys()):
407
278
for path in ignored[glob]:
408
self.outf.write("ignored %s matching \"%s\"\n"
409
% (path, glob))
279
print "ignored %s matching \"%s\"" % (path, glob)
410
280
else:
411
281
match_len = 0
412
282
for glob, paths in ignored.items():
413
283
match_len += len(paths)
414
self.outf.write("ignored %d file(s).\n" % match_len)
415
self.outf.write("If you wish to add some of these files,"
416
" please add them by name.\n")
284
print "ignored %d file(s)." % match_len
285
print "If you wish to add some of these files, please add them"\
286
" by name."
417
287
418
288
419
289
class cmd_mkdir(Command):
421
291
422
292
This is equivalent to creating the directory and then adding it.
423
293
"""
424
425
294
takes_args = ['dir+']
426
encoding_type = 'replace'
427
295
428
296
def run(self, dir_list):
429
297
for d in dir_list:
430
298
os.mkdir(d)
431
299
wt, dd = WorkingTree.open_containing(d)
432
300
wt.add([dd])
433
self.outf.write('added %s\n' % d)
301
print 'added', d
434
302
435
303
436
304
class cmd_relpath(Command):
437
305
"""Show path of a file relative to root"""
438
439
306
takes_args = ['filename']
440
307
hidden = True
441
308
442
309
@display_command
443
310
def run(self, filename):
444
# TODO: jam 20050106 Can relpath return a munged path if
445
# sys.stdout encoding cannot represent it?
446
311
tree, relpath = WorkingTree.open_containing(filename)
447
self.outf.write(relpath)
448
self.outf.write('\n')
312
print relpath
449
313
450
314
451
315
class cmd_inventory(Command):
452
316
"""Show inventory of the current working copy or a revision.
453
317
454
318
It is possible to limit the output to a particular entry
455
type using the --kind option. For example: --kind file.
456
457
It is also possible to restrict the list of files to a specific
458
set. For example: bzr inventory --show-ids this/file
319
type using the --kind option. For example; --kind file.
459
320
"""
460
461
hidden = True
462
_see_also = ['ls']
463
takes_options = [
464
'revision',
465
'show-ids',
466
Option('kind',
467
help='List entries of a particular kind: file, directory, symlink.',
468
type=unicode),
469
]
470
takes_args = ['file*']
471
321
takes_options = ['revision', 'show-ids', 'kind']
322
472
323
@display_command
473
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
324
def run(self, revision=None, show_ids=False, kind=None):
474
325
if kind and kind not in ['file', 'directory', 'symlink']:
475
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
476
477
work_tree, file_list = tree_files(file_list)
478
work_tree.lock_read()
479
try:
480
if revision is not None:
481
if len(revision) > 1:
482
raise errors.BzrCommandError(
483
'bzr inventory --revision takes exactly one revision'
484
' identifier')
485
revision_id = revision[0].as_revision_id(work_tree.branch)
486
tree = work_tree.branch.repository.revision_tree(revision_id)
487
488
extra_trees = [work_tree]
489
tree.lock_read()
490
else:
491
tree = work_tree
492
extra_trees = []
493
494
if file_list is not None:
495
file_ids = tree.paths2ids(file_list, trees=extra_trees,
496
require_versioned=True)
497
# find_ids_across_trees may include some paths that don't
498
# exist in 'tree'.
499
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
500
for file_id in file_ids if file_id in tree)
501
else:
502
entries = tree.inventory.entries()
503
finally:
504
tree.unlock()
505
if tree is not work_tree:
506
work_tree.unlock()
507
508
for path, entry in entries:
326
raise BzrCommandError('invalid kind specified')
327
tree = WorkingTree.open_containing(u'.')[0]
328
if revision is None:
329
inv = tree.read_working_inventory()
330
else:
331
if len(revision) > 1:
332
raise BzrCommandError('bzr inventory --revision takes'
333
' exactly one revision identifier')
334
inv = tree.branch.repository.get_revision_inventory(
335
revision[0].in_history(tree.branch).rev_id)
336
337
for path, entry in inv.entries():
509
338
if kind and kind != entry.kind:
510
339
continue
511
340
if show_ids:
512
self.outf.write('%-50s %s\n' % (path, entry.file_id))
341
print '%-50s %s' % (path, entry.file_id)
513
342
else:
514
self.outf.write(path)
515
self.outf.write('\n')
343
print path
516
344
517
345
518
346
class cmd_mv(Command):
519
347
"""Move or rename a file.
520
348
521
:Usage:
349
usage:
522
350
bzr mv OLDNAME NEWNAME
523
524
351
bzr mv SOURCE... DESTINATION
525
352
526
353
If the last argument is a versioned directory, all the other names
527
354
are moved into it. Otherwise, there must be exactly two arguments
528
and the file is changed to a new name.
529
530
If OLDNAME does not exist on the filesystem but is versioned and
531
NEWNAME does exist on the filesystem but is not versioned, mv
532
assumes that the file has been manually moved and only updates
533
its internal inventory to reflect that change.
534
The same is valid when moving many SOURCE files to a DESTINATION.
355
and the file is changed to a new name, which must not already exist.
535
356
536
357
Files cannot be moved between branches.
537
358
"""
538
539
359
takes_args = ['names*']
540
takes_options = [Option("after", help="Move only the bzr identifier"
541
" of the file, because the file has already been moved."),
542
]
543
360
aliases = ['move', 'rename']
544
encoding_type = 'replace'
545
546
def run(self, names_list, after=False):
547
if names_list is None:
548
names_list = []
549
361
362
def run(self, names_list):
550
363
if len(names_list) < 2:
551
raise errors.BzrCommandError("missing file argument")
364
raise BzrCommandError("missing file argument")
552
365
tree, rel_names = tree_files(names_list)
553
tree.lock_write()
554
try:
555
self._run(tree, names_list, rel_names, after)
556
finally:
557
tree.unlock()
558
559
def _run(self, tree, names_list, rel_names, after):
560
into_existing = osutils.isdir(names_list[-1])
561
if into_existing and len(names_list) == 2:
562
# special cases:
563
# a. case-insensitive filesystem and change case of dir
564
# b. move directory after the fact (if the source used to be
565
# a directory, but now doesn't exist in the working tree
566
# and the target is an existing directory, just rename it)
567
if (not tree.case_sensitive
568
and rel_names[0].lower() == rel_names[1].lower()):
569
into_existing = False
570
else:
571
inv = tree.inventory
572
from_id = tree.path2id(rel_names[0])
573
if (not osutils.lexists(names_list[0]) and
574
from_id and inv.get_file_kind(from_id) == "directory"):
575
into_existing = False
576
# move/rename
577
if into_existing:
366
367
if os.path.isdir(names_list[-1]):
578
368
# move into existing directory
579
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
580
self.outf.write("%s => %s\n" % pair)
369
for pair in tree.move(rel_names[:-1], rel_names[-1]):
370
print "%s => %s" % pair
581
371
else:
582
372
if len(names_list) != 2:
583
raise errors.BzrCommandError('to mv multiple files the'
584
' destination must be a versioned'
585
' directory')
586
tree.rename_one(rel_names[0], rel_names[1], after=after)
587
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
588
589
373
raise BzrCommandError('to mv multiple files the destination '
374
'must be a versioned directory')
375
tree.rename_one(rel_names[0], rel_names[1])
376
print "%s => %s" % (rel_names[0], rel_names[1])
377
378
590
379
class cmd_pull(Command):
591
380
"""Turn this branch into a mirror of another branch.
592
381
598
387
from one into the other. Once one branch has merged, the other should
599
388
be able to pull it again.
600
389
390
If branches have diverged, you can use 'bzr merge' to pull the text changes
391
from one into the other. Once one branch has merged, the other should
392
be able to pull it again.
393
601
394
If you want to forget your local changes and just update your branch to
602
395
match the remote one, use pull --overwrite.
603
396
604
397
If there is no default location set, the first pull will set it. After
605
398
that, you can omit the location to use the default. To change the
606
default, use --remember. The value will only be saved if the remote
607
location can be accessed.
608
609
Note: The location can be specified either in the form of a branch,
610
or in the form of a path to a file containing a merge directive generated
611
with bzr send.
399
default, use --remember.
612
400
"""
613
614
_see_also = ['push', 'update', 'status-flags']
615
takes_options = ['remember', 'overwrite', 'revision',
616
custom_help('verbose',
617
help='Show logs of pulled revisions.'),
618
Option('directory',
619
help='Branch to pull into, '
620
'rather than the one containing the working directory.',
621
short_name='d',
622
type=unicode,
623
),
624
]
401
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
625
402
takes_args = ['location?']
626
encoding_type = 'replace'
627
403
628
def run(self, location=None, remember=False, overwrite=False,
629
revision=None, verbose=False,
630
directory=None):
404
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
631
405
# FIXME: too much stuff is in the command class
632
revision_id = None
633
mergeable = None
634
if directory is None:
635
directory = u'.'
636
406
try:
637
tree_to = WorkingTree.open_containing(directory)[0]
407
tree_to = WorkingTree.open_containing(u'.')[0]
638
408
branch_to = tree_to.branch
639
except errors.NoWorkingTree:
409
except NoWorkingTree:
640
410
tree_to = None
641
branch_to = Branch.open_containing(directory)[0]
642
643
possible_transports = []
644
if location is not None:
645
try:
646
mergeable = bundle.read_mergeable_from_url(location,
647
possible_transports=possible_transports)
648
except errors.NotABundle:
649
mergeable = None
650
411
branch_to = Branch.open_containing(u'.')[0]
651
412
stored_loc = branch_to.get_parent()
652
413
if location is None:
653
414
if stored_loc is None:
654
raise errors.BzrCommandError("No pull location known or"
655
" specified.")
415
raise BzrCommandError("No pull location known or specified.")
656
416
else:
657
display_url = urlutils.unescape_for_display(stored_loc,
658
self.outf.encoding)
659
if not is_quiet():
660
self.outf.write("Using saved parent location: %s\n" % display_url)
417
print "Using saved location: %s" % stored_loc
661
418
location = stored_loc
662
419
663
if mergeable is not None:
664
if revision is not None:
665
raise errors.BzrCommandError(
666
'Cannot use -r with merge directives or bundles')
667
mergeable.install_revisions(branch_to.repository)
668
base_revision_id, revision_id, verified = \
669
mergeable.get_merge_request(branch_to.repository)
670
branch_from = branch_to
671
else:
672
branch_from = Branch.open(location,
673
possible_transports=possible_transports)
674
675
if branch_to.get_parent() is None or remember:
676
branch_to.set_parent(branch_from.base)
677
678
if revision is not None:
679
if len(revision) == 1:
680
revision_id = revision[0].as_revision_id(branch_from)
681
else:
682
raise errors.BzrCommandError(
683
'bzr pull --revision takes one value.')
684
685
branch_to.lock_write()
686
try:
687
if tree_to is not None:
688
change_reporter = delta._ChangeReporter(
689
unversioned_filter=tree_to.is_ignored)
690
result = tree_to.pull(branch_from, overwrite, revision_id,
691
change_reporter,
692
possible_transports=possible_transports)
693
else:
694
result = branch_to.pull(branch_from, overwrite, revision_id)
695
696
result.report(self.outf)
697
if verbose and result.old_revid != result.new_revid:
698
old_rh = list(
699
branch_to.repository.iter_reverse_revision_history(
700
result.old_revid))
701
old_rh.reverse()
702
new_rh = branch_to.revision_history()
703
log.show_changed_revisions(branch_to, old_rh, new_rh,
704
to_file=self.outf)
705
finally:
706
branch_to.unlock()
420
if branch_to.get_parent() is None or remember:
421
branch_to.set_parent(location)
422
423
branch_from = Branch.open(location)
424
425
if revision is None:
426
rev_id = None
427
elif len(revision) == 1:
428
rev_id = revision[0].in_history(branch_from).rev_id
429
else:
430
raise BzrCommandError('bzr pull --revision takes one value.')
431
432
old_rh = branch_to.revision_history()
433
if tree_to is not None:
434
count = tree_to.pull(branch_from, overwrite, rev_id)
435
else:
436
count = branch_to.pull(branch_from, overwrite, rev_id)
437
note('%d revision(s) pulled.' % (count,))
438
439
if verbose:
440
new_rh = branch_to.revision_history()
441
if old_rh != new_rh:
442
# Something changed
443
from bzrlib.log import show_changed_revisions
444
show_changed_revisions(branch_to, old_rh, new_rh)
707
445
708
446
709
447
class cmd_push(Command):
728
466
729
467
If there is no default push location set, the first push will set it.
730
468
After that, you can omit the location to use the default. To change the
731
default, use --remember. The value will only be saved if the remote
732
location can be accessed.
469
default, use --remember.
733
470
"""
734
735
_see_also = ['pull', 'update', 'working-trees']
736
takes_options = ['remember', 'overwrite', 'verbose', 'revision',
737
Option('create-prefix',
738
help='Create the path leading up to the branch '
739
'if it does not already exist.'),
740
Option('directory',
741
help='Branch to push from, '
742
'rather than the one containing the working directory.',
743
short_name='d',
744
type=unicode,
745
),
746
Option('use-existing-dir',
747
help='By default push will fail if the target'
748
' directory exists, but does not already'
749
' have a control directory. This flag will'
750
' allow push to proceed.'),
751
Option('stacked',
752
help='Create a stacked branch that references the public location '
753
'of the parent branch.'),
754
Option('stacked-on',
755
help='Create a stacked branch that refers to another branch '
756
'for the commit history. Only the work not present in the '
757
'referenced branch is included in the branch created.',
758
type=unicode),
759
]
471
takes_options = ['remember', 'overwrite',
472
Option('create-prefix',
473
help='Create the path leading up to the branch '
474
'if it does not already exist')]
760
475
takes_args = ['location?']
761
encoding_type = 'replace'
762
476
763
477
def run(self, location=None, remember=False, overwrite=False,
764
create_prefix=False, verbose=False, revision=None,
765
use_existing_dir=False, directory=None, stacked_on=None,
766
stacked=False):
767
from bzrlib.push import _show_push_branch
768
769
# Get the source branch and revision_id
770
if directory is None:
771
directory = '.'
772
br_from = Branch.open_containing(directory)[0]
773
if revision is not None:
774
if len(revision) == 1:
775
revision_id = revision[0].in_history(br_from).rev_id
776
else:
777
raise errors.BzrCommandError(
778
'bzr push --revision takes one value.')
779
else:
780
revision_id = br_from.last_revision()
781
782
# Get the stacked_on branch, if any
783
if stacked_on is not None:
784
stacked_on = urlutils.normalize_url(stacked_on)
785
elif stacked:
786
parent_url = br_from.get_parent()
787
if parent_url:
788
parent = Branch.open(parent_url)
789
stacked_on = parent.get_public_branch()
790
if not stacked_on:
791
# I considered excluding non-http url's here, thus forcing
792
# 'public' branches only, but that only works for some
793
# users, so it's best to just depend on the user spotting an
794
# error by the feedback given to them. RBC 20080227.
795
stacked_on = parent_url
796
if not stacked_on:
797
raise errors.BzrCommandError(
798
"Could not determine branch to refer to.")
799
800
# Get the destination location
478
create_prefix=False, verbose=False):
479
# FIXME: Way too big! Put this into a function called from the
480
# command.
481
from bzrlib.transport import get_transport
482
483
br_from = Branch.open_containing('.')[0]
484
stored_loc = br_from.get_push_location()
801
485
if location is None:
802
stored_loc = br_from.get_push_location()
803
486
if stored_loc is None:
804
raise errors.BzrCommandError(
805
"No push location known or specified.")
487
raise BzrCommandError("No push location known or specified.")
806
488
else:
807
display_url = urlutils.unescape_for_display(stored_loc,
808
self.outf.encoding)
809
self.outf.write("Using saved push location: %s\n" % display_url)
489
print "Using saved location: %s" % stored_loc
810
490
location = stored_loc
491
if br_from.get_push_location() is None or remember:
492
br_from.set_push_location(location)
493
try:
494
dir_to = bzrlib.bzrdir.BzrDir.open(location)
495
br_to = dir_to.open_branch()
496
except NotBranchError:
497
# create a branch.
498
transport = get_transport(location).clone('..')
499
if not create_prefix:
500
try:
501
transport.mkdir(transport.relpath(location))
502
except NoSuchFile:
503
raise BzrCommandError("Parent directory of %s "
504
"does not exist." % location)
505
else:
506
current = transport.base
507
needed = [(transport, transport.relpath(location))]
508
while needed:
509
try:
510
transport, relpath = needed[-1]
511
transport.mkdir(relpath)
512
needed.pop()
513
except NoSuchFile:
514
new_transport = transport.clone('..')
515
needed.append((new_transport,
516
new_transport.relpath(transport.base)))
517
if new_transport.base == transport.base:
518
raise BzrCommandError("Could not create "
519
"path prefix.")
520
dir_to = br_from.bzrdir.clone(location,
521
revision_id=br_from.last_revision())
522
br_to = dir_to.open_branch()
523
count = len(br_to.revision_history())
524
else:
525
old_rh = br_to.revision_history()
526
try:
527
try:
528
tree_to = dir_to.open_workingtree()
529
except errors.NotLocalUrl:
530
warning('This transport does not update the working '
531
'tree of: %s' % (br_to.base,))
532
count = br_to.pull(br_from, overwrite)
533
except NoWorkingTree:
534
count = br_to.pull(br_from, overwrite)
535
else:
536
count = tree_to.pull(br_from, overwrite)
537
except DivergedBranches:
538
raise BzrCommandError("These branches have diverged."
539
" Try a merge then push with overwrite.")
540
note('%d revision(s) pushed.' % (count,))
811
541
812
_show_push_branch(br_from, revision_id, location, self.outf,
813
verbose=verbose, overwrite=overwrite, remember=remember,
814
stacked_on=stacked_on, create_prefix=create_prefix,
815
use_existing_dir=use_existing_dir)
542
if verbose:
543
new_rh = br_to.revision_history()
544
if old_rh != new_rh:
545
# Something changed
546
from bzrlib.log import show_changed_revisions
547
show_changed_revisions(br_to, old_rh, new_rh)
816
548
817
549
818
550
class cmd_branch(Command):
820
552
821
553
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
822
554
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
823
If the FROM_LOCATION has no / or path separator embedded, the TO_LOCATION
824
is derived from the FROM_LOCATION by stripping a leading scheme or drive
825
identifier, if any. For example, "branch lp:foo-bar" will attempt to
826
create ./foo-bar.
827
555
828
556
To retrieve the branch as of a particular revision, supply the --revision
829
557
parameter, as in "branch foo/bar -r 5".
558
559
--basis is to speed up branching from remote branches. When specified, it
560
copies all the file-contents, inventory and revision data from the basis
561
branch before copying anything from the remote branch.
830
562
"""
831
832
_see_also = ['checkout']
833
563
takes_args = ['from_location', 'to_location?']
834
takes_options = ['revision', Option('hardlink',
835
help='Hard-link working tree files where possible.'),
836
Option('stacked',
837
help='Create a stacked branch referring to the source branch. '
838
'The new branch will depend on the availability of the source '
839
'branch for all operations.'),
840
]
564
takes_options = ['revision', 'basis']
841
565
aliases = ['get', 'clone']
842
566
843
def run(self, from_location, to_location=None, revision=None,
844
hardlink=False, stacked=False):
845
from bzrlib.tag import _merge_tags_if_possible
567
def run(self, from_location, to_location=None, revision=None, basis=None):
568
from bzrlib.osutils import rmtree
846
569
if revision is None:
847
570
revision = [None]
848
571
elif len(revision) > 1:
849
raise errors.BzrCommandError(
572
raise BzrCommandError(
850
573
'bzr branch --revision takes exactly 1 revision value')
851
852
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
853
from_location)
574
try:
575
br_from = Branch.open(from_location)
576
except OSError, e:
577
if e.errno == errno.ENOENT:
578
raise BzrCommandError('Source location "%s" does not'
579
' exist.' % to_location)
580
else:
581
raise
854
582
br_from.lock_read()
855
583
try:
584
if basis is not None:
585
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
586
else:
587
basis_dir = None
856
588
if len(revision) == 1 and revision[0] is not None:
857
revision_id = revision[0].as_revision_id(br_from)
589
revision_id = revision[0].in_history(br_from)[1]
858
590
else:
859
591
# FIXME - wt.last_revision, fallback to branch, fall back to
860
592
# None or perhaps NULL_REVISION to mean copy nothing
861
593
# RBC 20060209
862
594
revision_id = br_from.last_revision()
863
595
if to_location is None:
864
to_location = urlutils.derive_to_location(from_location)
865
to_transport = transport.get_transport(to_location)
596
to_location = os.path.basename(from_location.rstrip("/\\"))
597
name = None
598
else:
599
name = os.path.basename(to_location) + '\n'
866
600
try:
867
to_transport.mkdir('.')
868
except errors.FileExists:
869
raise errors.BzrCommandError('Target directory "%s" already'
870
' exists.' % to_location)
871
except errors.NoSuchFile:
872
raise errors.BzrCommandError('Parent of "%s" does not exist.'
873
% to_location)
601
os.mkdir(to_location)
602
except OSError, e:
603
if e.errno == errno.EEXIST:
604
raise BzrCommandError('Target directory "%s" already'
605
' exists.' % to_location)
606
if e.errno == errno.ENOENT:
607
raise BzrCommandError('Parent of "%s" does not exist.' %
608
to_location)
609
else:
610
raise
874
611
try:
875
612
# preserve whatever source format we have.
876
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
877
possible_transports=[to_transport],
878
accelerator_tree=accelerator_tree,
879
hardlink=hardlink, stacked=stacked)
613
dir = br_from.bzrdir.sprout(to_location, revision_id, basis_dir)
880
614
branch = dir.open_branch()
881
except errors.NoSuchRevision:
882
to_transport.delete_tree('.')
883
msg = "The branch %s has no revision %s." % (from_location,
884
revision[0])
885
raise errors.BzrCommandError(msg)
886
_merge_tags_if_possible(br_from, branch)
887
# If the source branch is stacked, the new branch may
888
# be stacked whether we asked for that explicitly or not.
889
# We therefore need a try/except here and not just 'if stacked:'
890
try:
891
note('Created new stacked branch referring to %s.' %
892
branch.get_stacked_on_url())
893
except (errors.NotStacked, errors.UnstackableBranchFormat,
894
errors.UnstackableRepositoryFormat), e:
895
note('Branched %d revision(s).' % branch.revno())
615
except bzrlib.errors.NoSuchRevision:
616
rmtree(to_location)
617
msg = "The branch %s has no revision %s." % (from_location, revision[0])
618
raise BzrCommandError(msg)
619
except bzrlib.errors.UnlistableBranch:
620
rmtree(to_location)
621
msg = "The branch %s cannot be used as a --basis" % (basis,)
622
raise BzrCommandError(msg)
623
if name:
624
branch.control_files.put_utf8('branch-name', name)
625
626
note('Branched %d revision(s).' % branch.revno())
896
627
finally:
897
628
br_from.unlock()
898
629
907
638
908
639
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
909
640
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
910
If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
911
is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
912
identifier, if any. For example, "checkout lp:foo-bar" will attempt to
913
create ./foo-bar.
914
641
915
642
To retrieve the branch as of a particular revision, supply the --revision
916
643
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
917
644
out of date [so you cannot commit] but it may be useful (i.e. to examine old
918
645
code.)
646
647
--basis is to speed up checking out from remote branches. When specified, it
648
uses the inventory and file contents from the basis branch in preference to the
649
branch being checked out.
919
650
"""
920
921
_see_also = ['checkouts', 'branch']
922
651
takes_args = ['branch_location?', 'to_location?']
923
takes_options = ['revision',
652
takes_options = ['revision', # , 'basis']
924
653
Option('lightweight',
925
help="Perform a lightweight checkout. Lightweight "
654
help="perform a lightweight checkout. Lightweight "
926
655
"checkouts depend on access to the branch for "
927
"every operation. Normal checkouts can perform "
656
"every operation. Normal checkouts can perform "
928
657
"common operations like diff and status without "
929
658
"such access, and also support local commits."
930
659
),
931
Option('files-from', type=str,
932
help="Get file contents from this tree."),
933
Option('hardlink',
934
help='Hard-link working tree files where possible.'
935
),
936
660
]
937
aliases = ['co']
938
661
939
def run(self, branch_location=None, to_location=None, revision=None,
940
lightweight=False, files_from=None, hardlink=False):
662
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
663
lightweight=False):
941
664
if revision is None:
942
665
revision = [None]
943
666
elif len(revision) > 1:
944
raise errors.BzrCommandError(
667
raise BzrCommandError(
945
668
'bzr checkout --revision takes exactly 1 revision value')
946
669
if branch_location is None:
947
branch_location = osutils.getcwd()
670
branch_location = bzrlib.osutils.getcwd()
948
671
to_location = branch_location
949
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
950
branch_location)
951
if files_from is not None:
952
accelerator_tree = WorkingTree.open(files_from)
672
source = Branch.open(branch_location)
953
673
if len(revision) == 1 and revision[0] is not None:
954
revision_id = revision[0].as_revision_id(source)
674
revision_id = revision[0].in_history(source)[1]
955
675
else:
956
676
revision_id = None
957
677
if to_location is None:
958
to_location = urlutils.derive_to_location(branch_location)
678
to_location = os.path.basename(branch_location.rstrip("/\\"))
959
679
# if the source and to_location are the same,
960
680
# and there is no working tree,
961
681
# then reconstitute a branch
962
if (osutils.abspath(to_location) ==
963
osutils.abspath(branch_location)):
682
if (bzrlib.osutils.abspath(to_location) ==
683
bzrlib.osutils.abspath(branch_location)):
964
684
try:
965
685
source.bzrdir.open_workingtree()
966
686
except errors.NoWorkingTree:
967
source.bzrdir.create_workingtree(revision_id)
687
source.bzrdir.create_workingtree()
968
688
return
969
source.create_checkout(to_location, revision_id, lightweight,
970
accelerator_tree, hardlink)
689
try:
690
os.mkdir(to_location)
691
except OSError, e:
692
if e.errno == errno.EEXIST:
693
raise BzrCommandError('Target directory "%s" already'
694
' exists.' % to_location)
695
if e.errno == errno.ENOENT:
696
raise BzrCommandError('Parent of "%s" does not exist.' %
697
to_location)
698
else:
699
raise
700
old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
701
bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
702
try:
703
if lightweight:
704
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
705
bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
706
else:
707
checkout_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(
708
to_location, force_new_tree=False)
709
checkout = checkout_branch.bzrdir
710
checkout_branch.bind(source)
711
if revision_id is not None:
712
rh = checkout_branch.revision_history()
713
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
714
checkout.create_workingtree(revision_id)
715
finally:
716
bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
971
717
972
718
973
719
class cmd_renames(Command):
976
722
# TODO: Option to show renames between two historical versions.
977
723
978
724
# TODO: Only show renames under dir, rather than in the whole branch.
979
_see_also = ['status']
980
725
takes_args = ['dir?']
981
726
982
727
@display_command
983
728
def run(self, dir=u'.'):
984
729
tree = WorkingTree.open_containing(dir)[0]
985
tree.lock_read()
986
try:
987
new_inv = tree.inventory
988
old_tree = tree.basis_tree()
989
old_tree.lock_read()
990
try:
991
old_inv = old_tree.inventory
992
renames = list(_mod_tree.find_renames(old_inv, new_inv))
993
renames.sort()
994
for old_name, new_name in renames:
995
self.outf.write("%s => %s\n" % (old_name, new_name))
996
finally:
997
old_tree.unlock()
998
finally:
999
tree.unlock()
730
old_inv = tree.basis_tree().inventory
731
new_inv = tree.read_working_inventory()
732
733
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
734
renames.sort()
735
for old_name, new_name in renames:
736
print "%s => %s" % (old_name, new_name)
1000
737
1001
738
1002
739
class cmd_update(Command):
1009
746
If you want to discard your local changes, you can just do a
1010
747
'bzr revert' instead of 'bzr commit' after the update.
1011
748
"""
1012
1013
_see_also = ['pull', 'working-trees', 'status-flags']
1014
749
takes_args = ['dir?']
1015
aliases = ['up']
1016
750
1017
751
def run(self, dir='.'):
1018
752
tree = WorkingTree.open_containing(dir)[0]
1019
possible_transports = []
1020
master = tree.branch.get_master_branch(
1021
possible_transports=possible_transports)
1022
if master is not None:
1023
tree.lock_write()
1024
else:
1025
tree.lock_tree_write()
753
tree.lock_write()
1026
754
try:
1027
existing_pending_merges = tree.get_parent_ids()[1:]
1028
last_rev = _mod_revision.ensure_null(tree.last_revision())
1029
if last_rev == _mod_revision.ensure_null(
1030
tree.branch.last_revision()):
755
if tree.last_revision() == tree.branch.last_revision():
1031
756
# may be up to date, check master too.
1032
if master is None or last_rev == _mod_revision.ensure_null(
1033
master.last_revision()):
1034
revno = tree.branch.revision_id_to_revno(last_rev)
1035
note("Tree is up to date at revision %d." % (revno,))
1036
return 0
1037
conflicts = tree.update(
1038
delta._ChangeReporter(unversioned_filter=tree.is_ignored),
1039
possible_transports=possible_transports)
1040
revno = tree.branch.revision_id_to_revno(
1041
_mod_revision.ensure_null(tree.last_revision()))
1042
note('Updated to revision %d.' % (revno,))
1043
if tree.get_parent_ids()[1:] != existing_pending_merges:
1044
note('Your local commits will now show as pending merges with '
1045
"'bzr status', and can be committed with 'bzr commit'.")
757
master = tree.branch.get_master_branch()
758
if master is None or master.last_revision == tree.last_revision():
759
note("Tree is up to date.")
760
return
761
conflicts = tree.update()
762
note('Updated to revision %d.' %
763
(tree.branch.revision_id_to_revno(tree.last_revision()),))
1046
764
if conflicts != 0:
1047
765
return 1
1048
766
else:
1060
778
1061
779
Branches and working trees will also report any missing revisions.
1062
780
"""
1063
_see_also = ['revno', 'working-trees', 'repositories']
1064
781
takes_args = ['location?']
1065
782
takes_options = ['verbose']
1066
encoding_type = 'replace'
1067
783
1068
784
@display_command
1069
785
def run(self, location=None, verbose=False):
1070
if verbose:
1071
noise_level = 2
1072
else:
1073
noise_level = 0
1074
786
from bzrlib.info import show_bzrdir_info
1075
787
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1076
verbose=noise_level, outfile=self.outf)
788
verbose=verbose)
1077
789
1078
790
1079
791
class cmd_remove(Command):
1080
"""Remove files or directories.
792
"""Make a file unversioned.
1081
793
1082
This makes bzr stop tracking changes to the specified files. bzr will delete
1083
them if they can easily be recovered using revert. If no options or
1084
parameters are given bzr will scan for files that are being tracked by bzr
1085
but missing in your tree and stop tracking them for you.
794
This makes bzr stop tracking changes to a versioned file. It does
795
not delete the working copy.
1086
796
"""
1087
takes_args = ['file*']
1088
takes_options = ['verbose',
1089
Option('new', help='Only remove files that have never been committed.'),
1090
RegistryOption.from_kwargs('file-deletion-strategy',
1091
'The file deletion mode to be used.',
1092
title='Deletion Strategy', value_switches=True, enum_switch=False,
1093
safe='Only delete files if they can be'
1094
' safely recovered (default).',
1095
keep="Don't delete any files.",
1096
force='Delete all the specified files, even if they can not be '
1097
'recovered and even if they are non-empty directories.')]
1098
aliases = ['rm', 'del']
1099
encoding_type = 'replace'
1100
1101
def run(self, file_list, verbose=False, new=False,
1102
file_deletion_strategy='safe'):
797
takes_args = ['file+']
798
takes_options = ['verbose']
799
aliases = ['rm']
800
801
def run(self, file_list, verbose=False):
1103
802
tree, file_list = tree_files(file_list)
1104
1105
if file_list is not None:
1106
file_list = [f for f in file_list]
1107
1108
tree.lock_write()
1109
try:
1110
# Heuristics should probably all move into tree.remove_smart or
1111
# some such?
1112
if new:
1113
added = tree.changes_from(tree.basis_tree(),
1114
specific_files=file_list).added
1115
file_list = sorted([f[0] for f in added], reverse=True)
1116
if len(file_list) == 0:
1117
raise errors.BzrCommandError('No matching files.')
1118
elif file_list is None:
1119
# missing files show up in iter_changes(basis) as
1120
# versioned-with-no-kind.
1121
missing = []
1122
for change in tree.iter_changes(tree.basis_tree()):
1123
# Find paths in the working tree that have no kind:
1124
if change[1][1] is not None and change[6][1] is None:
1125
missing.append(change[1][1])
1126
file_list = sorted(missing, reverse=True)
1127
file_deletion_strategy = 'keep'
1128
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1129
keep_files=file_deletion_strategy=='keep',
1130
force=file_deletion_strategy=='force')
1131
finally:
1132
tree.unlock()
803
tree.remove(file_list, verbose=verbose)
1133
804
1134
805
1135
806
class cmd_file_id(Command):
1139
810
same through all revisions where the file exists, even when it is
1140
811
moved or renamed.
1141
812
"""
1142
1143
813
hidden = True
1144
_see_also = ['inventory', 'ls']
1145
814
takes_args = ['filename']
1146
1147
815
@display_command
1148
816
def run(self, filename):
1149
817
tree, relpath = WorkingTree.open_containing(filename)
1150
i = tree.path2id(relpath)
1151
if i is None:
1152
raise errors.NotVersionedError(filename)
818
i = tree.inventory.path2id(relpath)
819
if i == None:
820
raise BzrError("%r is not a versioned file" % filename)
1153
821
else:
1154
self.outf.write(i + '\n')
822
print i
1155
823
1156
824
1157
825
class cmd_file_path(Command):
1158
826
"""Print path of file_ids to a file or directory.
1159
827
1160
828
This prints one line for each directory down to the target,
1161
starting at the branch root.
1162
"""
1163
829
starting at the branch root."""
1164
830
hidden = True
1165
831
takes_args = ['filename']
1166
1167
832
@display_command
1168
833
def run(self, filename):
1169
834
tree, relpath = WorkingTree.open_containing(filename)
1170
fid = tree.path2id(relpath)
1171
if fid is None:
1172
raise errors.NotVersionedError(filename)
1173
segments = osutils.splitpath(relpath)
1174
for pos in range(1, len(segments) + 1):
1175
path = osutils.joinpath(segments[:pos])
1176
self.outf.write("%s\n" % tree.path2id(path))
835
inv = tree.inventory
836
fid = inv.path2id(relpath)
837
if fid == None:
838
raise BzrError("%r is not a versioned file" % filename)
839
for fip in inv.get_idpath(fid):
840
print fip
1177
841
1178
842
1179
843
class cmd_reconcile(Command):
1194
858
1195
859
The branch *MUST* be on a listable system such as local disk or sftp.
1196
860
"""
1197
1198
_see_also = ['check']
1199
861
takes_args = ['branch?']
1200
862
1201
863
def run(self, branch="."):
1202
864
from bzrlib.reconcile import reconcile
1203
dir = bzrdir.BzrDir.open(branch)
865
dir = bzrlib.bzrdir.BzrDir.open(branch)
1204
866
reconcile(dir)
1205
867
1206
868
1207
869
class cmd_revision_history(Command):
1208
"""Display the list of revision ids on a branch."""
1209
1210
_see_also = ['log']
1211
takes_args = ['location?']
1212
870
"""Display list of revision ids on this branch."""
1213
871
hidden = True
1214
1215
872
@display_command
1216
def run(self, location="."):
1217
branch = Branch.open_containing(location)[0]
1218
for revid in branch.revision_history():
1219
self.outf.write(revid)
1220
self.outf.write('\n')
873
def run(self):
874
branch = WorkingTree.open_containing(u'.')[0].branch
875
for patchid in branch.revision_history():
876
print patchid
1221
877
1222
878
1223
879
class cmd_ancestry(Command):
1224
880
"""List all revisions merged into this branch."""
1225
1226
_see_also = ['log', 'revision-history']
1227
takes_args = ['location?']
1228
1229
881
hidden = True
1230
1231
882
@display_command
1232
def run(self, location="."):
1233
try:
1234
wt = WorkingTree.open_containing(location)[0]
1235
except errors.NoWorkingTree:
1236
b = Branch.open(location)
1237
last_revision = b.last_revision()
1238
else:
1239
b = wt.branch
1240
last_revision = wt.last_revision()
1241
1242
revision_ids = b.repository.get_ancestry(last_revision)
883
def run(self):
884
tree = WorkingTree.open_containing(u'.')[0]
885
b = tree.branch
886
# FIXME. should be tree.last_revision
887
revision_ids = b.repository.get_ancestry(b.last_revision())
888
assert revision_ids[0] == None
1243
889
revision_ids.pop(0)
1244
890
for revision_id in revision_ids:
1245
self.outf.write(revision_id + '\n')
891
print revision_id
1246
892
1247
893
1248
894
class cmd_init(Command):
1253
899
1254
900
If there is a repository in a parent directory of the location, then
1255
901
the history of the branch will be stored in the repository. Otherwise
1256
init creates a standalone branch which carries its own history
1257
in the .bzr directory.
902
init creates a standalone branch which carries its own history in
903
.bzr.
1258
904
1259
905
If there is already a branch at the location but it has no working tree,
1260
906
the tree can be populated with 'bzr checkout'.
1261
907
1262
Recipe for importing a tree of files::
1263
908
Recipe for importing a tree of files:
1264
909
cd ~/project
1265
910
bzr init
1266
911
bzr add .
1267
912
bzr status
1268
bzr commit -m "imported project"
913
bzr commit -m 'imported project'
1269
914
"""
1270
1271
_see_also = ['init-repository', 'branch', 'checkout']
1272
915
takes_args = ['location?']
1273
916
takes_options = [
1274
Option('create-prefix',
1275
help='Create the path leading up to the branch '
1276
'if it does not already exist.'),
1277
RegistryOption('format',
1278
help='Specify a format for this branch. '
1279
'See "help formats".',
1280
registry=bzrdir.format_registry,
1281
converter=bzrdir.format_registry.make_bzrdir,
1282
value_switches=True,
1283
title="Branch Format",
1284
),
1285
Option('append-revisions-only',
1286
help='Never change revnos or the existing log.'
1287
' Append revisions to it only.')
1288
]
1289
def run(self, location=None, format=None, append_revisions_only=False,
1290
create_prefix=False):
917
Option('format',
918
help='Specify a format for this branch. Current'
919
' formats are: default, knit, metaweave and'
920
' weave. Default is knit; metaweave and'
921
' weave are deprecated',
922
type=get_format_type),
923
]
924
def run(self, location=None, format=None):
925
from bzrlib.branch import Branch
1291
926
if format is None:
1292
format = bzrdir.format_registry.make_bzrdir('default')
927
format = get_format_type('default')
1293
928
if location is None:
1294
929
location = u'.'
1295
1296
to_transport = transport.get_transport(location)
1297
1298
# The path has to exist to initialize a
1299
# branch inside of it.
1300
# Just using os.mkdir, since I don't
1301
# believe that we want to create a bunch of
1302
# locations if the user supplies an extended path
1303
try:
1304
to_transport.ensure_base()
1305
except errors.NoSuchFile:
1306
if not create_prefix:
1307
raise errors.BzrCommandError("Parent directory of %s"
1308
" does not exist."
1309
"\nYou may supply --create-prefix to create all"
1310
" leading parent directories."
1311
% location)
1312
_create_prefix(to_transport)
1313
1314
try:
1315
existing_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
1316
except errors.NotBranchError:
930
else:
931
# The path has to exist to initialize a
932
# branch inside of it.
933
# Just using os.mkdir, since I don't
934
# believe that we want to create a bunch of
935
# locations if the user supplies an extended path
936
if not os.path.exists(location):
937
os.mkdir(location)
938
try:
939
existing_bzrdir = bzrdir.BzrDir.open(location)
940
except NotBranchError:
1317
941
# really a NotBzrDir error...
1318
create_branch = bzrdir.BzrDir.create_branch_convenience
1319
branch = create_branch(to_transport.base, format=format,
1320
possible_transports=[to_transport])
942
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1321
943
else:
1322
from bzrlib.transport.local import LocalTransport
1323
944
if existing_bzrdir.has_branch():
1324
if (isinstance(to_transport, LocalTransport)
1325
and not existing_bzrdir.has_workingtree()):
1326
raise errors.BranchExistsWithoutWorkingTree(location)
1327
raise errors.AlreadyBranchError(location)
945
if existing_bzrdir.has_workingtree():
946
raise errors.AlreadyBranchError(location)
947
else:
948
raise errors.BranchExistsWithoutWorkingTree(location)
1328
949
else:
1329
branch = existing_bzrdir.create_branch()
950
existing_bzrdir.create_branch()
1330
951
existing_bzrdir.create_workingtree()
1331
if append_revisions_only:
1332
try:
1333
branch.set_append_revisions_only(True)
1334
except errors.UpgradeRequired:
1335
raise errors.BzrCommandError('This branch format cannot be set'
1336
' to append-revisions-only. Try --experimental-branch6')
1337
if not is_quiet():
1338
from bzrlib.info import show_bzrdir_info
1339
show_bzrdir_info(bzrdir.BzrDir.open_containing_from_transport(
1340
to_transport)[0], verbose=0, outfile=self.outf)
1341
952
1342
953
1343
954
class cmd_init_repository(Command):
1344
955
"""Create a shared repository to hold branches.
1345
956
1346
New branches created under the repository directory will store their
1347
revisions in the repository, not in the branch directory.
1348
1349
If the --no-trees option is used then the branches in the repository
1350
will not have working trees by default.
1351
1352
:Examples:
1353
Create a shared repositories holding just branches::
1354
1355
bzr init-repo --no-trees repo
1356
bzr init repo/trunk
1357
1358
Make a lightweight checkout elsewhere::
1359
1360
bzr checkout --lightweight repo/trunk trunk-checkout
1361
cd trunk-checkout
1362
(add files here)
957
New branches created under the repository directory will store their revisions
958
in the repository, not in the branch directory, if the branch format supports
959
shared storage.
960
961
example:
962
bzr init-repo repo
963
bzr init repo/trunk
964
bzr checkout --lightweight repo/trunk trunk-checkout
965
cd trunk-checkout
966
(add files here)
1363
967
"""
1364
1365
_see_also = ['init', 'branch', 'checkout', 'repositories']
1366
takes_args = ["location"]
1367
takes_options = [RegistryOption('format',
1368
help='Specify a format for this repository. See'
1369
' "bzr help formats" for details.',
1370
registry=bzrdir.format_registry,
1371
converter=bzrdir.format_registry.make_bzrdir,
1372
value_switches=True, title='Repository format'),
1373
Option('no-trees',
1374
help='Branches in the repository will default to'
1375
' not having a working tree.'),
1376
]
968
takes_args = ["location"]
969
takes_options = [Option('format',
970
help='Specify a format for this repository.'
971
' Current formats are: default, knit,'
972
' metaweave and weave. Default is knit;'
973
' metaweave and weave are deprecated',
974
type=get_format_type),
975
Option('trees',
976
help='Allows branches in repository to have'
977
' a working tree')]
1377
978
aliases = ["init-repo"]
1378
1379
def run(self, location, format=None, no_trees=False):
979
def run(self, location, format=None, trees=False):
980
from bzrlib.transport import get_transport
1380
981
if format is None:
1381
format = bzrdir.format_registry.make_bzrdir('default')
1382
1383
if location is None:
1384
location = '.'
1385
1386
to_transport = transport.get_transport(location)
1387
to_transport.ensure_base()
1388
1389
newdir = format.initialize_on_transport(to_transport)
982
format = get_format_type('default')
983
transport = get_transport(location)
984
if not transport.has('.'):
985
transport.mkdir('')
986
newdir = format.initialize_on_transport(transport)
1390
987
repo = newdir.create_repository(shared=True)
1391
repo.set_make_working_trees(not no_trees)
1392
if not is_quiet():
1393
from bzrlib.info import show_bzrdir_info
1394
show_bzrdir_info(bzrdir.BzrDir.open_containing_from_transport(
1395
to_transport)[0], verbose=0, outfile=self.outf)
988
repo.set_make_working_trees(trees)
1396
989
1397
990
1398
991
class cmd_diff(Command):
1399
"""Show differences in the working tree, between revisions or branches.
992
"""Show differences in working tree.
1400
993
1401
If no arguments are given, all changes for the current tree are listed.
1402
If files are given, only the changes in those files are listed.
1403
Remote and multiple branches can be compared by using the --old and
1404
--new options. If not provided, the default for both is derived from
1405
the first argument, if any, or the current tree if no arguments are
1406
given.
994
If files are listed, only the changes in those files are listed.
995
Otherwise, all changes for the tree are listed.
1407
996
1408
997
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1409
998
produces patches suitable for "patch -p1".
1410
999
1411
:Exit values:
1412
1 - changed
1413
2 - unrepresentable changes
1414
3 - error
1415
0 - no change
1416
1417
:Examples:
1418
Shows the difference in the working tree versus the last commit::
1419
1420
bzr diff
1421
1422
Difference between the working tree and revision 1::
1423
1424
bzr diff -r1
1425
1426
Difference between revision 2 and revision 1::
1427
1428
bzr diff -r1..2
1429
1430
Difference between revision 2 and revision 1 for branch xxx::
1431
1432
bzr diff -r1..2 xxx
1433
1434
Show just the differences for file NEWS::
1435
1436
bzr diff NEWS
1437
1438
Show the differences in working tree xxx for file NEWS::
1439
1440
bzr diff xxx/NEWS
1441
1442
Show the differences from branch xxx to this working tree:
1443
1444
bzr diff --old xxx
1445
1446
Show the differences between two branches for file NEWS::
1447
1448
bzr diff --old xxx --new yyy NEWS
1449
1450
Same as 'bzr diff' but prefix paths with old/ and new/::
1451
1452
bzr diff --prefix old/:new/
1000
examples:
1001
bzr diff
1002
bzr diff -r1
1003
bzr diff -r1..2
1004
bzr diff --diff-prefix old/:new/
1005
bzr diff bzr.mine bzr.dev
1006
bzr diff foo.c
1453
1007
"""
1454
_see_also = ['status']
1008
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1009
# or a graphical diff.
1010
1011
# TODO: Python difflib is not exactly the same as unidiff; should
1012
# either fix it up or prefer to use an external diff.
1013
1014
# TODO: Selected-file diff is inefficient and doesn't show you
1015
# deleted files.
1016
1017
# TODO: This probably handles non-Unix newlines poorly.
1018
1455
1019
takes_args = ['file*']
1456
takes_options = [
1457
Option('diff-options', type=str,
1458
help='Pass these options to the external diff program.'),
1459
Option('prefix', type=str,
1460
short_name='p',
1461
help='Set prefixes added to old and new filenames, as '
1462
'two values separated by a colon. (eg "old/:new/").'),
1463
Option('old',
1464
help='Branch/tree to compare from.',
1465
type=unicode,
1466
),
1467
Option('new',
1468
help='Branch/tree to compare to.',
1469
type=unicode,
1470
),
1471
'revision',
1472
'change',
1473
Option('using',
1474
help='Use this command to compare files.',
1475
type=unicode,
1476
),
1477
]
1020
takes_options = ['revision', 'diff-options', 'prefix']
1478
1021
aliases = ['di', 'dif']
1479
encoding_type = 'exact'
1480
1022
1481
1023
@display_command
1482
1024
def run(self, revision=None, file_list=None, diff_options=None,
1483
prefix=None, old=None, new=None, using=None):
1484
from bzrlib.diff import _get_trees_to_diff, show_diff_trees
1025
prefix=None):
1026
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1485
1027
1486
1028
if (prefix is None) or (prefix == '0'):
1487
1029
# diff -p0 format
1490
1032
elif prefix == '1':
1491
1033
old_label = 'old/'
1492
1034
new_label = 'new/'
1493
elif ':' in prefix:
1035
else:
1036
if not ':' in prefix:
1037
raise BzrError("--diff-prefix expects two values separated by a colon")
1494
1038
old_label, new_label = prefix.split(":")
1039
1040
try:
1041
tree1, file_list = internal_tree_files(file_list)
1042
tree2 = None
1043
b = None
1044
b2 = None
1045
except FileInWrongBranch:
1046
if len(file_list) != 2:
1047
raise BzrCommandError("Files are in different branches")
1048
1049
tree1, file1 = WorkingTree.open_containing(file_list[0])
1050
tree2, file2 = WorkingTree.open_containing(file_list[1])
1051
if file1 != "" or file2 != "":
1052
# FIXME diff those two files. rbc 20051123
1053
raise BzrCommandError("Files are in different branches")
1054
file_list = None
1055
if revision is not None:
1056
if tree2 is not None:
1057
raise BzrCommandError("Can't specify -r with two branches")
1058
if (len(revision) == 1) or (revision[1].spec is None):
1059
return diff_cmd_helper(tree1, file_list, diff_options,
1060
revision[0],
1061
old_label=old_label, new_label=new_label)
1062
elif len(revision) == 2:
1063
return diff_cmd_helper(tree1, file_list, diff_options,
1064
revision[0], revision[1],
1065
old_label=old_label, new_label=new_label)
1066
else:
1067
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1495
1068
else:
1496
raise errors.BzrCommandError(
1497
'--prefix expects two values separated by a colon'
1498
' (eg "old/:new/")')
1499
1500
if revision and len(revision) > 2:
1501
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1502
' one or two revision specifiers')
1503
1504
old_tree, new_tree, specific_files, extra_trees = \
1505
_get_trees_to_diff(file_list, revision, old, new)
1506
return show_diff_trees(old_tree, new_tree, sys.stdout,
1507
specific_files=specific_files,
1508
external_diff_options=diff_options,
1509
old_label=old_label, new_label=new_label,
1510
extra_trees=extra_trees, using=using)
1069
if tree2 is not None:
1070
return show_diff_trees(tree1, tree2, sys.stdout,
1071
specific_files=file_list,
1072
external_diff_options=diff_options,
1073
old_label=old_label, new_label=new_label)
1074
else:
1075
return diff_cmd_helper(tree1, file_list, diff_options,
1076
old_label=old_label, new_label=new_label)
1511
1077
1512
1078
1513
1079
class cmd_deleted(Command):
1519
1085
# directories with readdir, rather than stating each one. Same
1520
1086
# level of effort but possibly much less IO. (Or possibly not,
1521
1087
# if the directories are very large...)
1522
_see_also = ['status', 'ls']
1523
takes_options = ['show-ids']
1524
1525
1088
@display_command
1526
1089
def run(self, show_ids=False):
1527
1090
tree = WorkingTree.open_containing(u'.')[0]
1528
tree.lock_read()
1529
try:
1530
old = tree.basis_tree()
1531
old.lock_read()
1532
try:
1533
for path, ie in old.inventory.iter_entries():
1534
if not tree.has_id(ie.file_id):
1535
self.outf.write(path)
1536
if show_ids:
1537
self.outf.write(' ')
1538
self.outf.write(ie.file_id)
1539
self.outf.write('\n')
1540
finally:
1541
old.unlock()
1542
finally:
1543
tree.unlock()
1091
old = tree.basis_tree()
1092
for path, ie in old.inventory.iter_entries():
1093
if not tree.has_id(ie.file_id):
1094
if show_ids:
1095
print '%-50s %s' % (path, ie.file_id)
1096
else:
1097
print path
1544
1098
1545
1099
1546
1100
class cmd_modified(Command):
1547
"""List files modified in working tree.
1548
"""
1549
1101
"""List files modified in working tree."""
1550
1102
hidden = True
1551
_see_also = ['status', 'ls']
1552
takes_options = [
1553
Option('null',
1554
help='Write an ascii NUL (\\0) separator '
1555
'between files rather than a newline.')
1556
]
1557
1558
1103
@display_command
1559
def run(self, null=False):
1104
def run(self):
1105
from bzrlib.delta import compare_trees
1106
1560
1107
tree = WorkingTree.open_containing(u'.')[0]
1561
td = tree.changes_from(tree.basis_tree())
1108
td = compare_trees(tree.basis_tree(), tree)
1109
1562
1110
for path, id, kind, text_modified, meta_modified in td.modified:
1563
if null:
1564
self.outf.write(path + '\0')
1565
else:
1566
self.outf.write(osutils.quotefn(path) + '\n')
1111
print path
1112
1567
1113
1568
1114
1569
1115
class cmd_added(Command):
1570
"""List files added in working tree.
1571
"""
1572
1116
"""List files added in working tree."""
1573
1117
hidden = True
1574
_see_also = ['status', 'ls']
1575
takes_options = [
1576
Option('null',
1577
help='Write an ascii NUL (\\0) separator '
1578
'between files rather than a newline.')
1579
]
1580
1581
1118
@display_command
1582
def run(self, null=False):
1119
def run(self):
1583
1120
wt = WorkingTree.open_containing(u'.')[0]
1584
wt.lock_read()
1585
try:
1586
basis = wt.basis_tree()
1587
basis.lock_read()
1588
try:
1589
basis_inv = basis.inventory
1590
inv = wt.inventory
1591
for file_id in inv:
1592
if file_id in basis_inv:
1593
continue
1594
if inv.is_root(file_id) and len(basis_inv) == 0:
1595
continue
1596
path = inv.id2path(file_id)
1597
if not os.access(osutils.abspath(path), os.F_OK):
1598
continue
1599
if null:
1600
self.outf.write(path + '\0')
1601
else:
1602
self.outf.write(osutils.quotefn(path) + '\n')
1603
finally:
1604
basis.unlock()
1605
finally:
1606
wt.unlock()
1607
1121
basis_inv = wt.basis_tree().inventory
1122
inv = wt.inventory
1123
for file_id in inv:
1124
if file_id in basis_inv:
1125
continue
1126
path = inv.id2path(file_id)
1127
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
1128
continue
1129
print path
1130
1131
1608
1132
1609
1133
class cmd_root(Command):
1610
1134
"""Show the tree root directory.
1611
1135
1612
1136
The root is the nearest enclosing directory with a .bzr control
1613
1137
directory."""
1614
1615
1138
takes_args = ['filename?']
1616
1139
@display_command
1617
1140
def run(self, filename=None):
1618
1141
"""Print the branch root."""
1619
1142
tree = WorkingTree.open_containing(filename)[0]
1620
self.outf.write(tree.basedir + '\n')
1621
1622
1623
def _parse_limit(limitstring):
1624
try:
1625
return int(limitstring)
1626
except ValueError:
1627
msg = "The limit argument must be an integer."
1628
raise errors.BzrCommandError(msg)
1143
print tree.basedir
1629
1144
1630
1145
1631
1146
class cmd_log(Command):
1637
1152
-r revision requests a specific revision, -r ..end or -r begin.. are
1638
1153
also valid.
1639
1154
1640
:Examples:
1641
Log the current branch::
1642
1643
bzr log
1644
1645
Log a file::
1646
1647
bzr log foo.c
1648
1649
Log the last 10 revisions of a branch::
1650
1651
bzr log -r -10.. http://server/branch
1155
examples:
1156
bzr log
1157
bzr log foo.c
1158
bzr log -r -10.. http://server/branch
1652
1159
"""
1653
1160
1654
1161
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1655
1162
1656
1163
takes_args = ['location?']
1657
takes_options = [
1658
Option('forward',
1659
help='Show from oldest to newest.'),
1660
Option('timezone',
1661
type=str,
1662
help='Display timezone as local, original, or utc.'),
1663
custom_help('verbose',
1664
help='Show files changed in each revision.'),
1665
'show-ids',
1666
'revision',
1667
'log-format',
1668
Option('message',
1669
short_name='m',
1670
help='Show revisions whose message matches this '
1671
'regular expression.',
1672
type=str),
1673
Option('limit',
1674
short_name='l',
1675
help='Limit the output to the first N revisions.',
1676
argname='N',
1677
type=_parse_limit),
1678
]
1679
encoding_type = 'replace'
1680
1164
takes_options = [Option('forward',
1165
help='show from oldest to newest'),
1166
'timezone',
1167
Option('verbose',
1168
help='show files changed in each revision'),
1169
'show-ids', 'revision',
1170
'log-format',
1171
'line', 'long',
1172
Option('message',
1173
help='show revisions whose message matches this regexp',
1174
type=str),
1175
'short',
1176
]
1681
1177
@display_command
1682
1178
def run(self, location=None, timezone='original',
1683
1179
verbose=False,
1686
1182
revision=None,
1687
1183
log_format=None,
1688
1184
message=None,
1689
limit=None):
1690
from bzrlib.log import show_log
1185
long=False,
1186
short=False,
1187
line=False):
1188
from bzrlib.log import log_formatter, show_log
1189
import codecs
1190
assert message is None or isinstance(message, basestring), \
1191
"invalid message argument %r" % message
1691
1192
direction = (forward and 'forward') or 'reverse'
1692
1193
1693
1194
# log everything
1695
1196
if location:
1696
1197
# find the file id to log:
1697
1198
1698
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
1699
location)
1199
dir, fp = bzrdir.BzrDir.open_containing(location)
1200
b = dir.open_branch()
1700
1201
if fp != '':
1701
if tree is None:
1702
tree = b.basis_tree()
1703
file_id = tree.path2id(fp)
1704
if file_id is None:
1705
raise errors.BzrCommandError(
1706
"Path does not have any revision history: %s" %
1707
location)
1202
try:
1203
# might be a tree:
1204
inv = dir.open_workingtree().inventory
1205
except (errors.NotBranchError, errors.NotLocalUrl):
1206
# either no tree, or is remote.
1207
inv = b.basis_tree().inventory
1208
file_id = inv.path2id(fp)
1708
1209
else:
1709
1210
# local dir only
1710
1211
# FIXME ? log the current subdir only RBC 20060203
1711
if revision is not None \
1712
and len(revision) > 0 and revision[0].get_branch():
1713
location = revision[0].get_branch()
1714
else:
1715
location = '.'
1716
dir, relpath = bzrdir.BzrDir.open_containing(location)
1212
dir, relpath = bzrdir.BzrDir.open_containing('.')
1717
1213
b = dir.open_branch()
1718
1214
1719
b.lock_read()
1720
try:
1721
if revision is None:
1722
rev1 = None
1723
rev2 = None
1724
elif len(revision) == 1:
1725
rev1 = rev2 = revision[0].in_history(b)
1726
elif len(revision) == 2:
1727
if revision[1].get_branch() != revision[0].get_branch():
1728
# b is taken from revision[0].get_branch(), and
1729
# show_log will use its revision_history. Having
1730
# different branches will lead to weird behaviors.
1731
raise errors.BzrCommandError(
1732
"Log doesn't accept two revisions in different"
1733
" branches.")
1734
rev1 = revision[0].in_history(b)
1735
rev2 = revision[1].in_history(b)
1736
else:
1737
raise errors.BzrCommandError(
1738
'bzr log --revision takes one or two values.')
1739
1740
if log_format is None:
1741
log_format = log.log_formatter_registry.get_default(b)
1742
1743
lf = log_format(show_ids=show_ids, to_file=self.outf,
1744
show_timezone=timezone)
1745
1746
show_log(b,
1747
lf,
1748
file_id,
1749
verbose=verbose,
1750
direction=direction,
1751
start_revision=rev1,
1752
end_revision=rev2,
1753
search=message,
1754
limit=limit)
1755
finally:
1756
b.unlock()
1215
if revision is None:
1216
rev1 = None
1217
rev2 = None
1218
elif len(revision) == 1:
1219
rev1 = rev2 = revision[0].in_history(b).revno
1220
elif len(revision) == 2:
1221
if revision[0].spec is None:
1222
# missing begin-range means first revision
1223
rev1 = 1
1224
else:
1225
rev1 = revision[0].in_history(b).revno
1226
1227
if revision[1].spec is None:
1228
# missing end-range means last known revision
1229
rev2 = b.revno()
1230
else:
1231
rev2 = revision[1].in_history(b).revno
1232
else:
1233
raise BzrCommandError('bzr log --revision takes one or two values.')
1234
1235
# By this point, the revision numbers are converted to the +ve
1236
# form if they were supplied in the -ve form, so we can do
1237
# this comparison in relative safety
1238
if rev1 > rev2:
1239
(rev2, rev1) = (rev1, rev2)
1240
1241
mutter('encoding log as %r', bzrlib.user_encoding)
1242
1243
# use 'replace' so that we don't abort if trying to write out
1244
# in e.g. the default C locale.
1245
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1246
1247
if (log_format == None):
1248
default = bzrlib.config.BranchConfig(b).log_format()
1249
log_format = get_log_format(long=long, short=short, line=line, default=default)
1250
1251
lf = log_formatter(log_format,
1252
show_ids=show_ids,
1253
to_file=outf,
1254
show_timezone=timezone)
1255
1256
show_log(b,
1257
lf,
1258
file_id,
1259
verbose=verbose,
1260
direction=direction,
1261
start_revision=rev1,
1262
end_revision=rev2,
1263
search=message)
1757
1264
1758
1265
1759
1266
def get_log_format(long=False, short=False, line=False, default='long'):
1770
1277
class cmd_touching_revisions(Command):
1771
1278
"""Return revision-ids which affected a particular file.
1772
1279
1773
A more user-friendly interface is "bzr log FILE".
1774
"""
1775
1280
A more user-friendly interface is "bzr log FILE"."""
1776
1281
hidden = True
1777
1282
takes_args = ["filename"]
1778
1779
1283
@display_command
1780
1284
def run(self, filename):
1781
1285
tree, relpath = WorkingTree.open_containing(filename)
1782
1286
b = tree.branch
1783
file_id = tree.path2id(relpath)
1784
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1785
self.outf.write("%6d %s\n" % (revno, what))
1287
inv = tree.read_working_inventory()
1288
file_id = inv.path2id(relpath)
1289
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1290
print "%6d %s" % (revno, what)
1786
1291
1787
1292
1788
1293
class cmd_ls(Command):
1789
1294
"""List files in a tree.
1790
1295
"""
1791
1792
_see_also = ['status', 'cat']
1793
takes_args = ['path?']
1794
1296
# TODO: Take a revision or remote path and list that tree instead.
1795
takes_options = [
1796
'verbose',
1797
'revision',
1798
Option('non-recursive',
1799
help='Don\'t recurse into subdirectories.'),
1800
Option('from-root',
1801
help='Print paths relative to the root of the branch.'),
1802
Option('unknown', help='Print unknown files.'),
1803
Option('versioned', help='Print versioned files.',
1804
short_name='V'),
1805
Option('ignored', help='Print ignored files.'),
1806
Option('null',
1807
help='Write an ascii NUL (\\0) separator '
1808
'between files rather than a newline.'),
1809
Option('kind',
1810
help='List entries of a particular kind: file, directory, symlink.',
1811
type=unicode),
1812
'show-ids',
1813
]
1297
hidden = True
1298
takes_options = ['verbose', 'revision',
1299
Option('non-recursive',
1300
help='don\'t recurse into sub-directories'),
1301
Option('from-root',
1302
help='Print all paths from the root of the branch.'),
1303
Option('unknown', help='Print unknown files'),
1304
Option('versioned', help='Print versioned files'),
1305
Option('ignored', help='Print ignored files'),
1306
1307
Option('null', help='Null separate the files'),
1308
]
1814
1309
@display_command
1815
def run(self, revision=None, verbose=False,
1310
def run(self, revision=None, verbose=False,
1816
1311
non_recursive=False, from_root=False,
1817
1312
unknown=False, versioned=False, ignored=False,
1818
null=False, kind=None, show_ids=False, path=None):
1819
1820
if kind and kind not in ('file', 'directory', 'symlink'):
1821
raise errors.BzrCommandError('invalid kind specified')
1313
null=False):
1822
1314
1823
1315
if verbose and null:
1824
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1316
raise BzrCommandError('Cannot set both --verbose and --null')
1825
1317
all = not (unknown or versioned or ignored)
1826
1318
1827
1319
selection = {'I':ignored, '?':unknown, 'V':versioned}
1828
1320
1829
if path is None:
1830
fs_path = '.'
1831
prefix = ''
1832
else:
1833
if from_root:
1834
raise errors.BzrCommandError('cannot specify both --from-root'
1835
' and PATH')
1836
fs_path = path
1837
prefix = path
1838
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
1839
fs_path)
1321
tree, relpath = WorkingTree.open_containing(u'.')
1840
1322
if from_root:
1841
1323
relpath = u''
1842
1324
elif relpath:
1843
1325
relpath += '/'
1844
1326
if revision is not None:
1845
tree = branch.repository.revision_tree(
1846
revision[0].as_revision_id(branch))
1847
elif tree is None:
1848
tree = branch.basis_tree()
1849
1850
tree.lock_read()
1851
try:
1852
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1853
if fp.startswith(relpath):
1854
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1855
if non_recursive and '/' in fp:
1856
continue
1857
if not all and not selection[fc]:
1858
continue
1859
if kind is not None and fkind != kind:
1860
continue
1861
if verbose:
1862
kindch = entry.kind_character()
1863
outstring = '%-8s %s%s' % (fc, fp, kindch)
1864
if show_ids and fid is not None:
1865
outstring = "%-50s %s" % (outstring, fid)
1866
self.outf.write(outstring + '\n')
1867
elif null:
1868
self.outf.write(fp + '\0')
1869
if show_ids:
1870
if fid is not None:
1871
self.outf.write(fid)
1872
self.outf.write('\0')
1873
self.outf.flush()
1874
else:
1875
if fid is not None:
1876
my_id = fid
1877
else:
1878
my_id = ''
1879
if show_ids:
1880
self.outf.write('%-50s %s\n' % (fp, my_id))
1881
else:
1882
self.outf.write(fp + '\n')
1883
finally:
1884
tree.unlock()
1327
tree = tree.branch.repository.revision_tree(
1328
revision[0].in_history(tree.branch).rev_id)
1329
for fp, fc, kind, fid, entry in tree.list_files():
1330
if fp.startswith(relpath):
1331
fp = fp[len(relpath):]
1332
if non_recursive and '/' in fp:
1333
continue
1334
if not all and not selection[fc]:
1335
continue
1336
if verbose:
1337
kindch = entry.kind_character()
1338
print '%-8s %s%s' % (fc, fp, kindch)
1339
elif null:
1340
sys.stdout.write(fp)
1341
sys.stdout.write('\0')
1342
sys.stdout.flush()
1343
else:
1344
print fp
1885
1345
1886
1346
1887
1347
class cmd_unknowns(Command):
1888
"""List unknown files.
1889
"""
1890
1891
hidden = True
1892
_see_also = ['ls']
1893
1348
"""List unknown files."""
1894
1349
@display_command
1895
1350
def run(self):
1351
from bzrlib.osutils import quotefn
1896
1352
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1897
self.outf.write(osutils.quotefn(f) + '\n')
1353
print quotefn(f)
1898
1354
1899
1355
1900
1356
class cmd_ignore(Command):
1901
"""Ignore specified files or patterns.
1902
1903
See ``bzr help patterns`` for details on the syntax of patterns.
1357
"""Ignore a command or pattern.
1904
1358
1905
1359
To remove patterns from the ignore list, edit the .bzrignore file.
1906
After adding, editing or deleting that file either indirectly by
1907
using this command or directly by using an editor, be sure to commit
1908
it.
1909
1910
Note: ignore patterns containing shell wildcards must be quoted from
1911
the shell on Unix.
1912
1913
:Examples:
1914
Ignore the top level Makefile::
1915
1916
bzr ignore ./Makefile
1917
1918
Ignore class files in all directories::
1919
1920
bzr ignore "*.class"
1921
1922
Ignore .o files under the lib directory::
1923
1924
bzr ignore "lib/**/*.o"
1925
1926
Ignore .o files under the lib directory::
1927
1928
bzr ignore "RE:lib/.*\.o"
1929
1930
Ignore everything but the "debian" toplevel directory::
1931
1932
bzr ignore "RE:(?!debian/).*"
1360
1361
If the pattern contains a slash, it is compared to the whole path
1362
from the branch root. Otherwise, it is compared to only the last
1363
component of the path. To match a file only in the root directory,
1364
prepend './'.
1365
1366
Ignore patterns are case-insensitive on case-insensitive systems.
1367
1368
Note: wildcards must be quoted from the shell on Unix.
1369
1370
examples:
1371
bzr ignore ./Makefile
1372
bzr ignore '*.class'
1933
1373
"""
1934
1935
_see_also = ['status', 'ignored', 'patterns']
1936
takes_args = ['name_pattern*']
1937
takes_options = [
1938
Option('old-default-rules',
1939
help='Write out the ignore rules bzr < 0.9 always used.')
1940
]
1374
# TODO: Complain if the filename is absolute
1375
takes_args = ['name_pattern']
1941
1376
1942
def run(self, name_pattern_list=None, old_default_rules=None):
1943
from bzrlib import ignores
1944
if old_default_rules is not None:
1945
# dump the rules and exit
1946
for pattern in ignores.OLD_DEFAULTS:
1947
print pattern
1948
return
1949
if not name_pattern_list:
1950
raise errors.BzrCommandError("ignore requires at least one "
1951
"NAME_PATTERN or --old-default-rules")
1952
name_pattern_list = [globbing.normalize_pattern(p)
1953
for p in name_pattern_list]
1954
for name_pattern in name_pattern_list:
1955
if (name_pattern[0] == '/' or
1956
(len(name_pattern) > 1 and name_pattern[1] == ':')):
1957
raise errors.BzrCommandError(
1958
"NAME_PATTERN should not be an absolute path")
1377
def run(self, name_pattern):
1378
from bzrlib.atomicfile import AtomicFile
1379
import os.path
1380
1959
1381
tree, relpath = WorkingTree.open_containing(u'.')
1960
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
1961
ignored = globbing.Globster(name_pattern_list)
1962
matches = []
1963
tree.lock_read()
1964
for entry in tree.list_files():
1965
id = entry[3]
1966
if id is not None:
1967
filename = entry[0]
1968
if ignored.match(filename):
1969
matches.append(filename.encode('utf-8'))
1970
tree.unlock()
1971
if len(matches) > 0:
1972
print "Warning: the following files are version controlled and" \
1973
" match your ignore pattern:\n%s" % ("\n".join(matches),)
1382
ifn = tree.abspath('.bzrignore')
1383
1384
if os.path.exists(ifn):
1385
f = open(ifn, 'rt')
1386
try:
1387
igns = f.read().decode('utf-8')
1388
finally:
1389
f.close()
1390
else:
1391
igns = ''
1392
1393
# TODO: If the file already uses crlf-style termination, maybe
1394
# we should use that for the newly added lines?
1395
1396
if igns and igns[-1] != '\n':
1397
igns += '\n'
1398
igns += name_pattern + '\n'
1399
1400
f = AtomicFile(ifn, 'wt')
1401
try:
1402
f.write(igns.encode('utf-8'))
1403
f.commit()
1404
finally:
1405
f.close()
1406
1407
inv = tree.inventory
1408
if inv.path2id('.bzrignore'):
1409
mutter('.bzrignore is already versioned')
1410
else:
1411
mutter('need to make new .bzrignore file versioned')
1412
tree.add(['.bzrignore'])
1974
1413
1975
1414
1976
1415
class cmd_ignored(Command):
1977
1416
"""List ignored files and the patterns that matched them.
1978
1417
1979
List all the ignored files and the ignore pattern that caused the file to
1980
be ignored.
1981
1982
Alternatively, to list just the files::
1983
1984
bzr ls --ignored
1985
"""
1986
1987
encoding_type = 'replace'
1988
_see_also = ['ignore', 'ls']
1989
1418
See also: bzr ignore"""
1990
1419
@display_command
1991
1420
def run(self):
1992
1421
tree = WorkingTree.open_containing(u'.')[0]
1993
tree.lock_read()
1994
try:
1995
for path, file_class, kind, file_id, entry in tree.list_files():
1996
if file_class != 'I':
1997
continue
1998
## XXX: Slightly inefficient since this was already calculated
1999
pat = tree.is_ignored(path)
2000
self.outf.write('%-50s %s\n' % (path, pat))
2001
finally:
2002
tree.unlock()
1422
for path, file_class, kind, file_id, entry in tree.list_files():
1423
if file_class != 'I':
1424
continue
1425
## XXX: Slightly inefficient since this was already calculated
1426
pat = tree.is_ignored(path)
1427
print '%-50s %s' % (path, pat)
2003
1428
2004
1429
2005
1430
class cmd_lookup_revision(Command):
2006
1431
"""Lookup the revision-id from a revision-number
2007
1432
2008
:Examples:
1433
example:
2009
1434
bzr lookup-revision 33
2010
1435
"""
2011
1436
hidden = True
2016
1441
try:
2017
1442
revno = int(revno)
2018
1443
except ValueError:
2019
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
1444
raise BzrCommandError("not a valid revision-number: %r" % revno)
2020
1445
2021
1446
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2022
1447
2023
1448
2024
1449
class cmd_export(Command):
2025
"""Export current or past revision to a destination directory or archive.
1450
"""Export past revision to destination directory.
2026
1451
2027
1452
If no revision is specified this exports the last committed revision.
2028
1453
2030
1455
given, try to find the format with the extension. If no extension
2031
1456
is found exports to a directory (equivalent to --format=dir).
2032
1457
2033
If root is supplied, it will be used as the root directory inside
2034
container formats (tar, zip, etc). If it is not supplied it will default
2035
to the exported filename. The root option has no effect for 'dir' format.
2036
2037
If branch is omitted then the branch containing the current working
2038
directory will be used.
2039
2040
Note: Export of tree with non-ASCII filenames to zip is not supported.
2041
2042
================= =========================
2043
Supported formats Autodetected by extension
2044
================= =========================
2045
dir (none)
1458
Root may be the top directory for tar, tgz and tbz2 formats. If none
1459
is given, the top directory will be the root name of the file.
1460
1461
Note: export of tree with non-ascii filenames to zip is not supported.
1462
1463
Supported formats Autodetected by extension
1464
----------------- -------------------------
1465
dir -
2046
1466
tar .tar
2047
1467
tbz2 .tar.bz2, .tbz2
2048
1468
tgz .tar.gz, .tgz
2049
1469
zip .zip
2050
================= =========================
2051
1470
"""
2052
takes_args = ['dest', 'branch_or_subdir?']
2053
takes_options = [
2054
Option('format',
2055
help="Type of file to export to.",
2056
type=unicode),
2057
'revision',
2058
Option('root',
2059
type=str,
2060
help="Name of the root directory inside the exported file."),
2061
]
2062
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2063
root=None):
1471
takes_args = ['dest']
1472
takes_options = ['revision', 'format', 'root']
1473
def run(self, dest, revision=None, format=None, root=None):
1474
import os.path
2064
1475
from bzrlib.export import export
2065
2066
if branch_or_subdir is None:
2067
tree = WorkingTree.open_containing(u'.')[0]
2068
b = tree.branch
2069
subdir = None
2070
else:
2071
b, subdir = Branch.open_containing(branch_or_subdir)
2072
1476
tree = WorkingTree.open_containing(u'.')[0]
1477
b = tree.branch
2073
1478
if revision is None:
2074
1479
# should be tree.last_revision FIXME
2075
1480
rev_id = b.last_revision()
2076
1481
else:
2077
1482
if len(revision) != 1:
2078
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
2079
rev_id = revision[0].as_revision_id(b)
1483
raise BzrError('bzr export --revision takes exactly 1 argument')
1484
rev_id = revision[0].in_history(b).rev_id
2080
1485
t = b.repository.revision_tree(rev_id)
2081
1486
try:
2082
export(t, dest, format, root, subdir)
1487
export(t, dest, format, root)
2083
1488
except errors.NoSuchExportFormat, e:
2084
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
1489
raise BzrCommandError('Unsupported export format: %s' % e.format)
2085
1490
2086
1491
2087
1492
class cmd_cat(Command):
2088
"""Write the contents of a file as of a given revision to standard output.
2089
2090
If no revision is nominated, the last revision is used.
2091
2092
Note: Take care to redirect standard output when using this command on a
2093
binary file.
2094
"""
2095
2096
_see_also = ['ls']
2097
takes_options = [
2098
Option('name-from-revision', help='The path name in the old tree.'),
2099
'revision',
2100
]
1493
"""Write a file's text from a previous revision."""
1494
1495
takes_options = ['revision']
2101
1496
takes_args = ['filename']
2102
encoding_type = 'exact'
2103
1497
2104
1498
@display_command
2105
def run(self, filename, revision=None, name_from_revision=False):
1499
def run(self, filename, revision=None):
2106
1500
if revision is not None and len(revision) != 1:
2107
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2108
" one revision specifier")
2109
tree, branch, relpath = \
2110
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2111
branch.lock_read()
1501
raise BzrCommandError("bzr cat --revision takes exactly one number")
1502
tree = None
2112
1503
try:
2113
return self._run(tree, branch, relpath, filename, revision,
2114
name_from_revision)
2115
finally:
2116
branch.unlock()
1504
tree, relpath = WorkingTree.open_containing(filename)
1505
b = tree.branch
1506
except NotBranchError:
1507
pass
2117
1508
2118
def _run(self, tree, b, relpath, filename, revision, name_from_revision):
2119
1509
if tree is None:
2120
tree = b.basis_tree()
1510
b, relpath = Branch.open_containing(filename)
2121
1511
if revision is None:
2122
1512
revision_id = b.last_revision()
2123
1513
else:
2124
revision_id = revision[0].as_revision_id(b)
2125
2126
cur_file_id = tree.path2id(relpath)
2127
rev_tree = b.repository.revision_tree(revision_id)
2128
old_file_id = rev_tree.path2id(relpath)
2129
2130
if name_from_revision:
2131
if old_file_id is None:
2132
raise errors.BzrCommandError("%r is not present in revision %s"
2133
% (filename, revision_id))
2134
else:
2135
content = rev_tree.get_file_text(old_file_id)
2136
elif cur_file_id is not None:
2137
content = rev_tree.get_file_text(cur_file_id)
2138
elif old_file_id is not None:
2139
content = rev_tree.get_file_text(old_file_id)
2140
else:
2141
raise errors.BzrCommandError("%r is not present in revision %s" %
2142
(filename, revision_id))
2143
self.outf.write(content)
1514
revision_id = revision[0].in_history(b).rev_id
1515
b.print_file(relpath, revision_id)
2144
1516
2145
1517
2146
1518
class cmd_local_time_offset(Command):
2148
1520
hidden = True
2149
1521
@display_command
2150
1522
def run(self):
2151
print osutils.local_time_offset()
1523
print bzrlib.osutils.local_time_offset()
2152
1524
2153
1525
2154
1526
2161
1533
committed. If a directory is specified then the directory and everything
2162
1534
within it is committed.
2163
1535
2164
When excludes are given, they take precedence over selected files.
2165
For example, too commit only changes within foo, but not changes within
2166
foo/bar::
2167
2168
bzr commit foo -x foo/bar
2169
2170
If author of the change is not the same person as the committer, you can
2171
specify the author's name using the --author option. The name should be
2172
in the same format as a committer-id, e.g. "John Doe <jdoe@example.com>".
2173
2174
1536
A selected-file commit may fail in some cases where the committed
2175
tree would be invalid. Consider::
2176
2177
bzr init foo
2178
mkdir foo/bar
2179
bzr add foo/bar
2180
bzr commit foo -m "committing foo"
2181
bzr mv foo/bar foo/baz
2182
mkdir foo/bar
2183
bzr add foo/bar
2184
bzr commit foo/bar -m "committing bar but not baz"
2185
2186
In the example above, the last commit will fail by design. This gives
2187
the user the opportunity to decide whether they want to commit the
2188
rename at the same time, separately first, or not at all. (As a general
2189
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2190
2191
Note: A selected-file commit after a merge is not yet supported.
1537
tree would be invalid, such as trying to commit a file in a
1538
newly-added directory that is not itself committed.
2192
1539
"""
2193
1540
# TODO: Run hooks on tree to-be-committed, and after commit.
2194
1541
2199
1546
2200
1547
# XXX: verbose currently does nothing
2201
1548
2202
_see_also = ['bugs', 'uncommit']
2203
1549
takes_args = ['selected*']
2204
takes_options = [
2205
ListOption('exclude', type=str, short_name='x',
2206
help="Do not consider changes made to a given path."),
2207
Option('message', type=unicode,
2208
short_name='m',
2209
help="Description of the new revision."),
2210
'verbose',
2211
Option('unchanged',
2212
help='Commit even if nothing has changed.'),
2213
Option('file', type=str,
2214
short_name='F',
2215
argname='msgfile',
2216
help='Take commit message from this file.'),
2217
Option('strict',
2218
help="Refuse to commit if there are unknown "
2219
"files in the working tree."),
2220
ListOption('fixes', type=str,
2221
help="Mark a bug as being fixed by this revision."),
2222
Option('author', type=unicode,
2223
help="Set the author's name, if it's different "
2224
"from the committer."),
2225
Option('local',
2226
help="Perform a local commit in a bound "
2227
"branch. Local commits are not pushed to "
2228
"the master branch until a normal commit "
2229
"is performed."
2230
),
2231
Option('show-diff',
2232
help='When no message is supplied, show the diff along'
2233
' with the status summary in the message editor.'),
2234
]
1550
takes_options = ['message', 'verbose',
1551
Option('unchanged',
1552
help='commit even if nothing has changed'),
1553
Option('file', type=str,
1554
argname='msgfile',
1555
help='file containing commit message'),
1556
Option('strict',
1557
help="refuse to commit if there are unknown "
1558
"files in the working tree."),
1559
Option('local',
1560
help="perform a local only commit in a bound "
1561
"branch. Such commits are not pushed to "
1562
"the master branch until a normal commit "
1563
"is performed."
1564
),
1565
]
2235
1566
aliases = ['ci', 'checkin']
2236
1567
2237
def _get_bug_fix_properties(self, fixes, branch):
2238
properties = []
2239
# Configure the properties for bug fixing attributes.
2240
for fixed_bug in fixes:
2241
tokens = fixed_bug.split(':')
2242
if len(tokens) != 2:
2243
raise errors.BzrCommandError(
2244
"Invalid bug %s. Must be in the form of 'tag:id'. "
2245
"Commit refused." % fixed_bug)
2246
tag, bug_id = tokens
2247
try:
2248
bug_url = bugtracker.get_bug_url(tag, branch, bug_id)
2249
except errors.UnknownBugTrackerAbbreviation:
2250
raise errors.BzrCommandError(
2251
'Unrecognized bug %s. Commit refused.' % fixed_bug)
2252
except errors.MalformedBugIdentifier:
2253
raise errors.BzrCommandError(
2254
"Invalid bug identifier for %s. Commit refused."
2255
% fixed_bug)
2256
properties.append('%s fixed' % bug_url)
2257
return '\n'.join(properties)
2258
2259
def run(self, message=None, file=None, verbose=False, selected_list=None,
2260
unchanged=False, strict=False, local=False, fixes=None,
2261
author=None, show_diff=False, exclude=None):
2262
from bzrlib.errors import (
2263
PointlessCommit,
2264
ConflictsInTree,
2265
StrictCommitFailed
2266
)
2267
from bzrlib.msgeditor import (
2268
edit_commit_message_encoded,
2269
make_commit_message_template_encoded
2270
)
1568
def run(self, message=None, file=None, verbose=True, selected_list=None,
1569
unchanged=False, strict=False, local=False):
1570
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1571
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1572
StrictCommitFailed)
1573
from bzrlib.msgeditor import edit_commit_message, \
1574
make_commit_message_template
1575
from tempfile import TemporaryFile
1576
import codecs
2271
1577
2272
1578
# TODO: Need a blackbox test for invoking the external editor; may be
2273
1579
# slightly problematic to run this cross-platform.
2274
1580
2275
1581
# TODO: do more checks that the commit will succeed before
2276
1582
# spending the user's valuable time typing a commit message.
2277
2278
properties = {}
2279
1583
#
1584
# TODO: if the commit *does* happen to fail, then save the commit
1585
# message to a temporary file where it can be recovered
2280
1586
tree, selected_list = tree_files(selected_list)
2281
1587
if selected_list == ['']:
2282
1588
# workaround - commit of root of tree should be exactly the same
2284
1590
# selected-file merge commit is not done yet
2285
1591
selected_list = []
2286
1592
2287
if fixes is None:
2288
fixes = []
2289
bug_property = self._get_bug_fix_properties(fixes, tree.branch)
2290
if bug_property:
2291
properties['bugs'] = bug_property
2292
2293
1593
if local and not tree.branch.get_bound_location():
2294
1594
raise errors.LocalRequiresBoundBranch()
2295
2296
def get_message(commit_obj):
2297
"""Callback to get commit message"""
2298
my_message = message
2299
if my_message is None and not file:
2300
t = make_commit_message_template_encoded(tree,
2301
selected_list, diff=show_diff,
2302
output_encoding=bzrlib.user_encoding)
2303
my_message = edit_commit_message_encoded(t)
2304
if my_message is None:
2305
raise errors.BzrCommandError("please specify a commit"
2306
" message with either --message or --file")
2307
elif my_message and file:
2308
raise errors.BzrCommandError(
2309
"please specify either --message or --file")
2310
if file:
2311
my_message = codecs.open(file, 'rt',
2312
bzrlib.user_encoding).read()
2313
if my_message == "":
2314
raise errors.BzrCommandError("empty commit message specified")
2315
return my_message
2316
1595
if message is None and not file:
1596
template = make_commit_message_template(tree, selected_list)
1597
message = edit_commit_message(template)
1598
if message is None:
1599
raise BzrCommandError("please specify a commit message"
1600
" with either --message or --file")
1601
elif message and file:
1602
raise BzrCommandError("please specify either --message or --file")
1603
1604
if file:
1605
import codecs
1606
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1607
1608
if message == "":
1609
raise BzrCommandError("empty commit message specified")
1610
1611
if verbose:
1612
reporter = ReportCommitToLog()
1613
else:
1614
reporter = NullCommitReporter()
1615
2317
1616
try:
2318
tree.commit(message_callback=get_message,
2319
specific_files=selected_list,
1617
tree.commit(message, specific_files=selected_list,
2320
1618
allow_pointless=unchanged, strict=strict, local=local,
2321
reporter=None, verbose=verbose, revprops=properties,
2322
author=author,
2323
exclude=safe_relpath_files(tree, exclude))
1619
reporter=reporter)
2324
1620
except PointlessCommit:
2325
1621
# FIXME: This should really happen before the file is read in;
2326
1622
# perhaps prepare the commit; get the message; then actually commit
2327
raise errors.BzrCommandError("no changes to commit."
2328
" use --unchanged to commit anyhow")
1623
raise BzrCommandError("no changes to commit",
1624
["use --unchanged to commit anyhow"])
2329
1625
except ConflictsInTree:
2330
raise errors.BzrCommandError('Conflicts detected in working '
2331
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
2332
' resolve.')
1626
raise BzrCommandError("Conflicts detected in working tree. "
1627
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
2333
1628
except StrictCommitFailed:
2334
raise errors.BzrCommandError("Commit refused because there are"
2335
" unknown files in the working tree.")
1629
raise BzrCommandError("Commit refused because there are unknown "
1630
"files in the working tree.")
2336
1631
except errors.BoundBranchOutOfDate, e:
2337
raise errors.BzrCommandError(str(e) + "\n"
2338
'To commit to master branch, run update and then commit.\n'
2339
'You can also pass --local to commit to continue working '
2340
'disconnected.')
1632
raise BzrCommandError(str(e)
1633
+ ' Either unbind, update, or'
1634
' pass --local to commit.')
2341
1635
2342
1636
2343
1637
class cmd_check(Command):
2344
"""Validate working tree structure, branch consistency and repository history.
2345
2346
This command checks various invariants about branch and repository storage
2347
to detect data corruption or bzr bugs.
2348
2349
The working tree and branch checks will only give output if a problem is
2350
detected. The output fields of the repository check are:
2351
2352
revisions: This is just the number of revisions checked. It doesn't
2353
indicate a problem.
2354
versionedfiles: This is just the number of versionedfiles checked. It
2355
doesn't indicate a problem.
2356
unreferenced ancestors: Texts that are ancestors of other texts, but
2357
are not properly referenced by the revision ancestry. This is a
2358
subtle problem that Bazaar can work around.
2359
unique file texts: This is the total number of unique file contents
2360
seen in the checked revisions. It does not indicate a problem.
2361
repeated file texts: This is the total number of repeated texts seen
2362
in the checked revisions. Texts can be repeated when their file
2363
entries are modified, but the file contents are not. It does not
2364
indicate a problem.
2365
2366
If no restrictions are specified, all Bazaar data that is found at the given
2367
location will be checked.
2368
2369
:Examples:
2370
2371
Check the tree and branch at 'foo'::
2372
2373
bzr check --tree --branch foo
2374
2375
Check only the repository at 'bar'::
2376
2377
bzr check --repo bar
2378
2379
Check everything at 'baz'::
2380
2381
bzr check baz
1638
"""Validate consistency of branch history.
1639
1640
This command checks various invariants about the branch storage to
1641
detect data corruption or bzr bugs.
2382
1642
"""
2383
2384
_see_also = ['reconcile']
2385
takes_args = ['path?']
2386
takes_options = ['verbose',
2387
Option('branch', help="Check the branch related to the"
2388
" current directory."),
2389
Option('repo', help="Check the repository related to the"
2390
" current directory."),
2391
Option('tree', help="Check the working tree related to"
2392
" the current directory.")]
2393
2394
def run(self, path=None, verbose=False, branch=False, repo=False,
2395
tree=False):
2396
from bzrlib.check import check_dwim
2397
if path is None:
2398
path = '.'
2399
if not branch and not repo and not tree:
2400
branch = repo = tree = True
2401
check_dwim(path, verbose, do_branch=branch, do_repo=repo, do_tree=tree)
1643
takes_args = ['branch?']
1644
takes_options = ['verbose']
1645
1646
def run(self, branch=None, verbose=False):
1647
from bzrlib.check import check
1648
if branch is None:
1649
tree = WorkingTree.open_containing()[0]
1650
branch = tree.branch
1651
else:
1652
branch = Branch.open(branch)
1653
check(branch, verbose)
1654
1655
1656
class cmd_scan_cache(Command):
1657
hidden = True
1658
def run(self):
1659
from bzrlib.hashcache import HashCache
1660
1661
c = HashCache(u'.')
1662
c.read()
1663
c.scan()
1664
1665
print '%6d stats' % c.stat_count
1666
print '%6d in hashcache' % len(c._cache)
1667
print '%6d files removed from cache' % c.removed_count
1668
print '%6d hashes updated' % c.update_count
1669
print '%6d files changed too recently to cache' % c.danger_count
1670
1671
if c.needs_write:
1672
c.write()
2402
1673
2403
1674
2404
1675
class cmd_upgrade(Command):
2408
1679
this command. When the default format has changed you may also be warned
2409
1680
during other operations to upgrade.
2410
1681
"""
2411
2412
_see_also = ['check']
2413
1682
takes_args = ['url?']
2414
1683
takes_options = [
2415
RegistryOption('format',
2416
help='Upgrade to a specific format. See "bzr help'
2417
' formats" for details.',
2418
registry=bzrdir.format_registry,
2419
converter=bzrdir.format_registry.make_bzrdir,
2420
value_switches=True, title='Branch format'),
1684
Option('format',
1685
help='Upgrade to a specific format. Current formats'
1686
' are: default, knit, metaweave and weave.'
1687
' Default is knit; metaweave and weave are'
1688
' deprecated',
1689
type=get_format_type),
2421
1690
]
2422
1691
1692
2423
1693
def run(self, url='.', format=None):
2424
1694
from bzrlib.upgrade import upgrade
2425
1695
if format is None:
2426
format = bzrdir.format_registry.make_bzrdir('default')
1696
format = get_format_type('default')
2427
1697
upgrade(url, format)
2428
1698
2429
1699
2430
1700
class cmd_whoami(Command):
2431
"""Show or set bzr user id.
2432
2433
:Examples:
2434
Show the email of the current user::
2435
2436
bzr whoami --email
2437
2438
Set the current user::
2439
2440
bzr whoami "Frank Chu <fchu@example.com>"
2441
"""
2442
takes_options = [ Option('email',
2443
help='Display email address only.'),
2444
Option('branch',
2445
help='Set identity for the current branch instead of '
2446
'globally.'),
2447
]
2448
takes_args = ['name?']
2449
encoding_type = 'replace'
1701
"""Show bzr user id."""
1702
takes_options = ['email']
2450
1703
2451
1704
@display_command
2452
def run(self, email=False, branch=False, name=None):
2453
if name is None:
2454
# use branch if we're inside one; otherwise global config
2455
try:
2456
c = Branch.open_containing('.')[0].get_config()
2457
except errors.NotBranchError:
2458
c = config.GlobalConfig()
2459
if email:
2460
self.outf.write(c.user_email() + '\n')
2461
else:
2462
self.outf.write(c.username() + '\n')
2463
return
2464
2465
# display a warning if an email address isn't included in the given name.
1705
def run(self, email=False):
2466
1706
try:
2467
config.extract_email_address(name)
2468
except errors.NoEmailInUsername, e:
2469
warning('"%s" does not seem to contain an email address. '
2470
'This is allowed, but not recommended.', name)
1707
b = WorkingTree.open_containing(u'.')[0].branch
1708
config = bzrlib.config.BranchConfig(b)
1709
except NotBranchError:
1710
config = bzrlib.config.GlobalConfig()
2471
1711
2472
# use global config unless --branch given
2473
if branch:
2474
c = Branch.open_containing('.')[0].get_config()
1712
if email:
1713
print config.user_email()
2475
1714
else:
2476
c = config.GlobalConfig()
2477
c.set_user_option('email', name)
1715
print config.username()
2478
1716
2479
1717
2480
1718
class cmd_nick(Command):
2483
1721
If unset, the tree root directory name is used as the nickname
2484
1722
To print the current nickname, execute with no argument.
2485
1723
"""
2486
2487
_see_also = ['info']
2488
1724
takes_args = ['nickname?']
2489
1725
def run(self, nickname=None):
2490
1726
branch = Branch.open_containing(u'.')[0]
2495
1731
2496
1732
@display_command
2497
1733
def printme(self, branch):
2498
print branch.nick
2499
2500
2501
class cmd_alias(Command):
2502
"""Set/unset and display aliases.
2503
2504
:Examples:
2505
Show the current aliases::
2506
2507
bzr alias
2508
2509
Show the alias specified for 'll'::
2510
2511
bzr alias ll
2512
2513
Set an alias for 'll'::
2514
2515
bzr alias ll="log --line -r-10..-1"
2516
2517
To remove an alias for 'll'::
2518
2519
bzr alias --remove ll
2520
2521
"""
2522
takes_args = ['name?']
2523
takes_options = [
2524
Option('remove', help='Remove the alias.'),
2525
]
2526
2527
def run(self, name=None, remove=False):
2528
if remove:
2529
self.remove_alias(name)
2530
elif name is None:
2531
self.print_aliases()
2532
else:
2533
equal_pos = name.find('=')
2534
if equal_pos == -1:
2535
self.print_alias(name)
2536
else:
2537
self.set_alias(name[:equal_pos], name[equal_pos+1:])
2538
2539
def remove_alias(self, alias_name):
2540
if alias_name is None:
2541
raise errors.BzrCommandError(
2542
'bzr alias --remove expects an alias to remove.')
2543
# If alias is not found, print something like:
2544
# unalias: foo: not found
2545
c = config.GlobalConfig()
2546
c.unset_alias(alias_name)
2547
2548
@display_command
2549
def print_aliases(self):
2550
"""Print out the defined aliases in a similar format to bash."""
2551
aliases = config.GlobalConfig().get_aliases()
2552
for key, value in sorted(aliases.iteritems()):
2553
self.outf.write('bzr alias %s="%s"\n' % (key, value))
2554
2555
@display_command
2556
def print_alias(self, alias_name):
2557
from bzrlib.commands import get_alias
2558
alias = get_alias(alias_name)
2559
if alias is None:
2560
self.outf.write("bzr alias: %s: not found\n" % alias_name)
2561
else:
2562
self.outf.write(
2563
'bzr alias %s="%s"\n' % (alias_name, ' '.join(alias)))
2564
2565
def set_alias(self, alias_name, alias_command):
2566
"""Save the alias in the global config."""
2567
c = config.GlobalConfig()
2568
c.set_alias(alias_name, alias_command)
1734
print branch.nick
2569
1735
2570
1736
2571
1737
class cmd_selftest(Command):
2572
1738
"""Run internal test suite.
2573
1739
2574
If arguments are given, they are regular expressions that say which tests
2575
should run. Tests matching any expression are run, and other tests are
2576
not run.
2577
2578
Alternatively if --first is given, matching tests are run first and then
2579
all other tests are run. This is useful if you have been working in a
2580
particular area, but want to make sure nothing else was broken.
2581
2582
If --exclude is given, tests that match that regular expression are
2583
excluded, regardless of whether they match --first or not.
2584
2585
To help catch accidential dependencies between tests, the --randomize
2586
option is useful. In most cases, the argument used is the word 'now'.
2587
Note that the seed used for the random number generator is displayed
2588
when this option is used. The seed can be explicitly passed as the
2589
argument to this option if required. This enables reproduction of the
2590
actual ordering used if and when an order sensitive problem is encountered.
2591
2592
If --list-only is given, the tests that would be run are listed. This is
2593
useful when combined with --first, --exclude and/or --randomize to
2594
understand their impact. The test harness reports "Listed nn tests in ..."
2595
instead of "Ran nn tests in ..." when list mode is enabled.
1740
This creates temporary test directories in the working directory,
1741
but not existing data is affected. These directories are deleted
1742
if the tests pass, or left behind to help in debugging if they
1743
fail and --keep-output is specified.
1744
1745
If arguments are given, they are regular expressions that say
1746
which tests should run.
2596
1747
2597
1748
If the global option '--no-plugins' is given, plugins are not loaded
2598
1749
before running the selftests. This has two effects: features provided or
2599
1750
modified by plugins will not be tested, and tests provided by plugins will
2600
1751
not be run.
2601
1752
2602
Tests that need working space on disk use a common temporary directory,
2603
typically inside $TMPDIR or /tmp.
2604
2605
:Examples:
2606
Run only tests relating to 'ignore'::
2607
2608
bzr selftest ignore
2609
2610
Disable plugins and list tests as they're run::
2611
2612
bzr --no-plugins selftest -v
1753
examples:
1754
bzr selftest ignore
1755
bzr --no-plugins selftest -v
2613
1756
"""
1757
# TODO: --list should give a list of all available tests
1758
2614
1759
# NB: this is used from the class without creating an instance, which is
2615
1760
# why it does not have a self parameter.
2616
1761
def get_transport_type(typestring):
2626
1771
return FakeNFSServer
2627
1772
msg = "No known transport type %s. Supported types are: sftp\n" %\
2628
1773
(typestring)
2629
raise errors.BzrCommandError(msg)
1774
raise BzrCommandError(msg)
2630
1775
2631
1776
hidden = True
2632
1777
takes_args = ['testspecs*']
2633
1778
takes_options = ['verbose',
2634
Option('one',
2635
help='Stop when one test fails.',
2636
short_name='1',
2637
),
2638
Option('transport',
1779
Option('one', help='stop when one test fails'),
1780
Option('keep-output',
1781
help='keep output directories when tests fail'),
1782
Option('transport',
2639
1783
help='Use a different transport by default '
2640
1784
'throughout the test suite.',
2641
1785
type=get_transport_type),
2642
Option('benchmark',
2643
help='Run the benchmarks rather than selftests.'),
1786
Option('benchmark', help='run the bzr bencharks.'),
2644
1787
Option('lsprof-timed',
2645
help='Generate lsprof output for benchmarked'
1788
help='generate lsprof output for benchmarked'
2646
1789
' sections of code.'),
2647
Option('cache-dir', type=str,
2648
help='Cache intermediate benchmark output in this '
2649
'directory.'),
2650
Option('first',
2651
help='Run all tests, but run specified tests first.',
2652
short_name='f',
2653
),
2654
Option('list-only',
2655
help='List the tests instead of running them.'),
2656
Option('randomize', type=str, argname="SEED",
2657
help='Randomize the order of tests using the given'
2658
' seed or "now" for the current time.'),
2659
Option('exclude', type=str, argname="PATTERN",
2660
short_name='x',
2661
help='Exclude tests that match this regular'
2662
' expression.'),
2663
Option('strict', help='Fail on missing dependencies or '
2664
'known failures.'),
2665
Option('load-list', type=str, argname='TESTLISTFILE',
2666
help='Load a test id list from a text file.'),
2667
ListOption('debugflag', type=str, short_name='E',
2668
help='Turn on a selftest debug flag.'),
2669
ListOption('starting-with', type=str, argname='TESTID',
2670
param_name='starting_with', short_name='s',
2671
help=
2672
'Load only the tests starting with TESTID.'),
2673
1790
]
2674
encoding_type = 'replace'
2675
1791
2676
def run(self, testspecs_list=None, verbose=False, one=False,
2677
transport=None, benchmark=None,
2678
lsprof_timed=None, cache_dir=None,
2679
first=False, list_only=False,
2680
randomize=None, exclude=None, strict=False,
2681
load_list=None, debugflag=None, starting_with=None):
1792
def run(self, testspecs_list=None, verbose=None, one=False,
1793
keep_output=False, transport=None, benchmark=None,
1794
lsprof_timed=None):
2682
1795
import bzrlib.ui
2683
1796
from bzrlib.tests import selftest
2684
1797
import bzrlib.benchmarks as benchmarks
2685
from bzrlib.benchmarks import tree_creator
2686
2687
# Make deprecation warnings visible, unless -Werror is set
2688
symbol_versioning.activate_deprecation_warnings(override=False)
2689
2690
if cache_dir is not None:
2691
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2692
if not list_only:
2693
print 'testing: %s' % (osutils.realpath(sys.argv[0]),)
2694
print ' %s (%s python%s)' % (
2695
bzrlib.__path__[0],
2696
bzrlib.version_string,
2697
bzrlib._format_version_tuple(sys.version_info),
2698
)
1798
# we don't want progress meters from the tests to go to the
1799
# real output; and we don't want log messages cluttering up
1800
# the real logs.
1801
save_ui = bzrlib.ui.ui_factory
1802
print '%10s: %s' % ('bzr', bzrlib.osutils.realpath(sys.argv[0]))
1803
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2699
1804
print
2700
if testspecs_list is not None:
2701
pattern = '|'.join(testspecs_list)
2702
else:
2703
pattern = ".*"
2704
if benchmark:
2705
test_suite_factory = benchmarks.test_suite
2706
# Unless user explicitly asks for quiet, be verbose in benchmarks
2707
verbose = not is_quiet()
2708
# TODO: should possibly lock the history file...
2709
benchfile = open(".perf_history", "at", buffering=1)
2710
else:
2711
test_suite_factory = None
2712
benchfile = None
1805
bzrlib.trace.info('running tests...')
2713
1806
try:
2714
result = selftest(verbose=verbose,
1807
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1808
if testspecs_list is not None:
1809
pattern = '|'.join(testspecs_list)
1810
else:
1811
pattern = ".*"
1812
if benchmark:
1813
test_suite_factory = benchmarks.test_suite
1814
if verbose is None:
1815
verbose = True
1816
else:
1817
test_suite_factory = None
1818
if verbose is None:
1819
verbose = False
1820
result = selftest(verbose=verbose,
2715
1821
pattern=pattern,
2716
stop_on_failure=one,
1822
stop_on_failure=one,
1823
keep_output=keep_output,
2717
1824
transport=transport,
2718
1825
test_suite_factory=test_suite_factory,
2719
lsprof_timed=lsprof_timed,
2720
bench_history=benchfile,
2721
matching_tests_first=first,
2722
list_only=list_only,
2723
random_seed=randomize,
2724
exclude_pattern=exclude,
2725
strict=strict,
2726
load_list=load_list,
2727
debug_flags=debugflag,
2728
starting_with=starting_with,
2729
)
1826
lsprof_timed=lsprof_timed)
1827
if result:
1828
bzrlib.trace.info('tests passed')
1829
else:
1830
bzrlib.trace.info('tests failed')
1831
return int(not result)
2730
1832
finally:
2731
if benchfile is not None:
2732
benchfile.close()
2733
if result:
2734
note('tests passed')
2735
else:
2736
note('tests failed')
2737
return int(not result)
1833
bzrlib.ui.ui_factory = save_ui
1834
1835
1836
def _get_bzr_branch():
1837
"""If bzr is run from a branch, return Branch or None"""
1838
import bzrlib.errors
1839
from bzrlib.branch import Branch
1840
from bzrlib.osutils import abspath
1841
from os.path import dirname
1842
1843
try:
1844
branch = Branch.open(dirname(abspath(dirname(__file__))))
1845
return branch
1846
except bzrlib.errors.BzrError:
1847
return None
1848
1849
1850
def show_version():
1851
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1852
# is bzrlib itself in a branch?
1853
branch = _get_bzr_branch()
1854
if branch:
1855
rh = branch.revision_history()
1856
revno = len(rh)
1857
print " bzr checkout, revision %d" % (revno,)
1858
print " nick: %s" % (branch.nick,)
1859
if rh:
1860
print " revid: %s" % (rh[-1],)
1861
print bzrlib.__copyright__
1862
print "http://bazaar-vcs.org/"
1863
print
1864
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1865
print "you may use, modify and redistribute it under the terms of the GNU"
1866
print "General Public License version 2 or later."
2738
1867
2739
1868
2740
1869
class cmd_version(Command):
2741
1870
"""Show version of bzr."""
2742
2743
encoding_type = 'replace'
2744
takes_options = [
2745
Option("short", help="Print just the version number."),
2746
]
2747
2748
1871
@display_command
2749
def run(self, short=False):
2750
from bzrlib.version import show_version
2751
if short:
2752
self.outf.write(bzrlib.version_string + '\n')
2753
else:
2754
show_version(to_file=self.outf)
2755
1872
def run(self):
1873
show_version()
2756
1874
2757
1875
class cmd_rocks(Command):
2758
1876
"""Statement of optimism."""
2759
2760
1877
hidden = True
2761
2762
1878
@display_command
2763
1879
def run(self):
2764
print "It sure does!"
1880
print "it sure does!"
2765
1881
2766
1882
2767
1883
class cmd_find_merge_base(Command):
2768
"""Find and print a base revision for merging two branches."""
1884
"""Find and print a base revision for merging two branches.
1885
"""
2769
1886
# TODO: Options to specify revisions on either side, as if
2770
1887
# merging only part of the history.
2771
1888
takes_args = ['branch', 'other']
2773
1890
2774
1891
@display_command
2775
1892
def run(self, branch, other):
2776
from bzrlib.revision import ensure_null
1893
from bzrlib.revision import common_ancestor, MultipleRevisionSources
2777
1894
2778
1895
branch1 = Branch.open_containing(branch)[0]
2779
1896
branch2 = Branch.open_containing(other)[0]
2780
branch1.lock_read()
2781
try:
2782
branch2.lock_read()
2783
try:
2784
last1 = ensure_null(branch1.last_revision())
2785
last2 = ensure_null(branch2.last_revision())
2786
2787
graph = branch1.repository.get_graph(branch2.repository)
2788
base_rev_id = graph.find_unique_lca(last1, last2)
2789
2790
print 'merge base is revision %s' % base_rev_id
2791
finally:
2792
branch2.unlock()
2793
finally:
2794
branch1.unlock()
1897
1898
history_1 = branch1.revision_history()
1899
history_2 = branch2.revision_history()
1900
1901
last1 = branch1.last_revision()
1902
last2 = branch2.last_revision()
1903
1904
source = MultipleRevisionSources(branch1.repository,
1905
branch2.repository)
1906
1907
base_rev_id = common_ancestor(last1, last2, source)
1908
1909
print 'merge base is revision %s' % base_rev_id
1910
1911
return
1912
1913
if base_revno is None:
1914
raise bzrlib.errors.UnrelatedBranches()
1915
1916
print ' r%-6d in %s' % (base_revno, branch)
1917
1918
other_revno = branch2.revision_id_to_revno(base_revid)
1919
1920
print ' r%-6d in %s' % (other_revno, other)
1921
2795
1922
2796
1923
2797
1924
class cmd_merge(Command):
2798
1925
"""Perform a three-way merge.
2799
1926
2800
The source of the merge can be specified either in the form of a branch,
2801
or in the form of a path to a file containing a merge directive generated
2802
with bzr send. If neither is specified, the default is the upstream branch
2803
or the branch most recently merged using --remember.
2804
2805
When merging a branch, by default the tip will be merged. To pick a different
2806
revision, pass --revision. If you specify two values, the first will be used as
2807
BASE and the second one as OTHER. Merging individual revisions, or a subset of
2808
available revisions, like this is commonly referred to as "cherrypicking".
2809
2810
Revision numbers are always relative to the branch being merged.
1927
The branch is the branch you will merge from. By default, it will
1928
merge the latest revision. If you specify a revision, that
1929
revision will be merged. If you specify two revisions, the first
1930
will be used as a BASE, and the second one as OTHER. Revision
1931
numbers are always relative to the specified branch.
2811
1932
2812
1933
By default, bzr will try to merge in all new work from the other
2813
1934
branch, automatically determining an appropriate base. If this
2822
1943
2823
1944
If there is no default branch set, the first merge will set it. After
2824
1945
that, you can omit the branch to use the default. To change the
2825
default, use --remember. The value will only be saved if the remote
2826
location can be accessed.
2827
2828
The results of the merge are placed into the destination working
2829
directory, where they can be reviewed (with bzr diff), tested, and then
2830
committed to record the result of the merge.
1946
default, use --remember.
1947
1948
Examples:
1949
1950
To merge the latest revision from bzr.dev
1951
bzr merge ../bzr.dev
1952
1953
To merge changes up to and including revision 82 from bzr.dev
1954
bzr merge -r 82 ../bzr.dev
1955
1956
To merge the changes introduced by 82, without previous changes:
1957
bzr merge -r 81..82 ../bzr.dev
2831
1958
2832
1959
merge refuses to run if there are any uncommitted changes, unless
2833
1960
--force is given.
2834
1961
2835
:Examples:
2836
To merge the latest revision from bzr.dev::
2837
2838
bzr merge ../bzr.dev
2839
2840
To merge changes up to and including revision 82 from bzr.dev::
2841
2842
bzr merge -r 82 ../bzr.dev
2843
2844
To merge the changes introduced by 82, without previous changes::
2845
2846
bzr merge -r 81..82 ../bzr.dev
2847
2848
To apply a merge directive contained in in /tmp/merge:
2849
2850
bzr merge /tmp/merge
1962
The following merge types are available:
2851
1963
"""
2852
2853
encoding_type = 'exact'
2854
_see_also = ['update', 'remerge', 'status-flags']
2855
takes_args = ['location?']
2856
takes_options = [
2857
'change',
2858
'revision',
2859
Option('force',
2860
help='Merge even if the destination tree has uncommitted changes.'),
2861
'merge-type',
2862
'reprocess',
2863
'remember',
2864
Option('show-base', help="Show base revision text in "
2865
"conflicts."),
2866
Option('uncommitted', help='Apply uncommitted changes'
2867
' from a working copy, instead of branch changes.'),
2868
Option('pull', help='If the destination is already'
2869
' completely merged into the source, pull from the'
2870
' source rather than merging. When this happens,'
2871
' you do not need to commit the result.'),
2872
Option('directory',
2873
help='Branch to merge into, '
2874
'rather than the one containing the working directory.',
2875
short_name='d',
2876
type=unicode,
2877
),
2878
Option('preview', help='Instead of merging, show a diff of the merge.')
2879
]
2880
2881
def run(self, location=None, revision=None, force=False,
2882
merge_type=None, show_base=False, reprocess=False, remember=False,
2883
uncommitted=False, pull=False,
2884
directory=None,
2885
preview=False,
2886
):
1964
takes_args = ['branch?']
1965
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
1966
Option('show-base', help="Show base revision text in "
1967
"conflicts")]
1968
1969
def help(self):
1970
from merge import merge_type_help
1971
from inspect import getdoc
1972
return getdoc(self) + '\n' + merge_type_help()
1973
1974
def run(self, branch=None, revision=None, force=False, merge_type=None,
1975
show_base=False, reprocess=False, remember=False):
2887
1976
if merge_type is None:
2888
merge_type = _mod_merge.Merge3Merger
2889
2890
if directory is None: directory = u'.'
2891
possible_transports = []
2892
merger = None
2893
allow_pending = True
2894
verified = 'inapplicable'
2895
tree = WorkingTree.open_containing(directory)[0]
2896
change_reporter = delta._ChangeReporter(
2897
unversioned_filter=tree.is_ignored)
2898
cleanups = []
1977
merge_type = Merge3Merger
1978
1979
tree = WorkingTree.open_containing(u'.')[0]
1980
stored_loc = tree.branch.get_parent()
1981
if branch is None:
1982
if stored_loc is None:
1983
raise BzrCommandError("No merge branch known or specified.")
1984
else:
1985
print "Using saved branch: %s" % stored_loc
1986
branch = stored_loc
1987
1988
if tree.branch.get_parent() is None or remember:
1989
tree.branch.set_parent(branch)
1990
1991
if revision is None or len(revision) < 1:
1992
base = [None, None]
1993
other = [branch, -1]
1994
other_branch, path = Branch.open_containing(branch)
1995
else:
1996
if len(revision) == 1:
1997
base = [None, None]
1998
other_branch, path = Branch.open_containing(branch)
1999
revno = revision[0].in_history(other_branch).revno
2000
other = [branch, revno]
2001
else:
2002
assert len(revision) == 2
2003
if None in revision:
2004
raise BzrCommandError(
2005
"Merge doesn't permit that revision specifier.")
2006
b, path = Branch.open_containing(branch)
2007
2008
base = [branch, revision[0].in_history(b).revno]
2009
other = [branch, revision[1].in_history(b).revno]
2010
if path != "":
2011
interesting_files = [path]
2012
else:
2013
interesting_files = None
2014
pb = bzrlib.ui.ui_factory.nested_progress_bar()
2899
2015
try:
2900
pb = ui.ui_factory.nested_progress_bar()
2901
cleanups.append(pb.finished)
2902
tree.lock_write()
2903
cleanups.append(tree.unlock)
2904
if location is not None:
2905
try:
2906
mergeable = bundle.read_mergeable_from_url(location,
2907
possible_transports=possible_transports)
2908
except errors.NotABundle:
2909
mergeable = None
2910
else:
2911
if uncommitted:
2912
raise errors.BzrCommandError('Cannot use --uncommitted'
2913
' with bundles or merge directives.')
2914
2915
if revision is not None:
2916
raise errors.BzrCommandError(
2917
'Cannot use -r with merge directives or bundles')
2918
merger, verified = _mod_merge.Merger.from_mergeable(tree,
2919
mergeable, pb)
2920
2921
if merger is None and uncommitted:
2922
if revision is not None and len(revision) > 0:
2923
raise errors.BzrCommandError('Cannot use --uncommitted and'
2924
' --revision at the same time.')
2925
location = self._select_branch_location(tree, location)[0]
2926
other_tree, other_path = WorkingTree.open_containing(location)
2927
merger = _mod_merge.Merger.from_uncommitted(tree, other_tree,
2928
pb)
2929
allow_pending = False
2930
if other_path != '':
2931
merger.interesting_files = [other_path]
2932
2933
if merger is None:
2934
merger, allow_pending = self._get_merger_from_branch(tree,
2935
location, revision, remember, possible_transports, pb)
2936
2937
merger.merge_type = merge_type
2938
merger.reprocess = reprocess
2939
merger.show_base = show_base
2940
self.sanity_check_merger(merger)
2941
if (merger.base_rev_id == merger.other_rev_id and
2942
merger.other_rev_id is not None):
2943
note('Nothing to do.')
2016
try:
2017
conflict_count = merge(other, base, check_clean=(not force),
2018
merge_type=merge_type,
2019
reprocess=reprocess,
2020
show_base=show_base,
2021
pb=pb, file_list=interesting_files)
2022
finally:
2023
pb.finished()
2024
if conflict_count != 0:
2025
return 1
2026
else:
2944
2027
return 0
2945
if pull:
2946
if merger.interesting_files is not None:
2947
raise errors.BzrCommandError('Cannot pull individual files')
2948
if (merger.base_rev_id == tree.last_revision()):
2949
result = tree.pull(merger.other_branch, False,
2950
merger.other_rev_id)
2951
result.report(self.outf)
2952
return 0
2953
merger.check_basis(not force)
2954
if preview:
2955
return self._do_preview(merger)
2956
else:
2957
return self._do_merge(merger, change_reporter, allow_pending,
2958
verified)
2959
finally:
2960
for cleanup in reversed(cleanups):
2961
cleanup()
2962
2963
def _do_preview(self, merger):
2964
from bzrlib.diff import show_diff_trees
2965
tree_merger = merger.make_merger()
2966
tt = tree_merger.make_preview_transform()
2967
try:
2968
result_tree = tt.get_preview_tree()
2969
show_diff_trees(merger.this_tree, result_tree, self.outf,
2970
old_label='', new_label='')
2971
finally:
2972
tt.finalize()
2973
2974
def _do_merge(self, merger, change_reporter, allow_pending, verified):
2975
merger.change_reporter = change_reporter
2976
conflict_count = merger.do_merge()
2977
if allow_pending:
2978
merger.set_pending()
2979
if verified == 'failed':
2980
warning('Preview patch does not match changes')
2981
if conflict_count != 0:
2982
return 1
2983
else:
2984
return 0
2985
2986
def sanity_check_merger(self, merger):
2987
if (merger.show_base and
2988
not merger.merge_type is _mod_merge.Merge3Merger):
2989
raise errors.BzrCommandError("Show-base is not supported for this"
2990
" merge type. %s" % merger.merge_type)
2991
if merger.reprocess and not merger.merge_type.supports_reprocess:
2992
raise errors.BzrCommandError("Conflict reduction is not supported"
2993
" for merge type %s." %
2994
merger.merge_type)
2995
if merger.reprocess and merger.show_base:
2996
raise errors.BzrCommandError("Cannot do conflict reduction and"
2997
" show base.")
2998
2999
def _get_merger_from_branch(self, tree, location, revision, remember,
3000
possible_transports, pb):
3001
"""Produce a merger from a location, assuming it refers to a branch."""
3002
from bzrlib.tag import _merge_tags_if_possible
3003
# find the branch locations
3004
other_loc, user_location = self._select_branch_location(tree, location,
3005
revision, -1)
3006
if revision is not None and len(revision) == 2:
3007
base_loc, _unused = self._select_branch_location(tree,
3008
location, revision, 0)
3009
else:
3010
base_loc = other_loc
3011
# Open the branches
3012
other_branch, other_path = Branch.open_containing(other_loc,
3013
possible_transports)
3014
if base_loc == other_loc:
3015
base_branch = other_branch
3016
else:
3017
base_branch, base_path = Branch.open_containing(base_loc,
3018
possible_transports)
3019
# Find the revision ids
3020
if revision is None or len(revision) < 1 or revision[-1] is None:
3021
other_revision_id = _mod_revision.ensure_null(
3022
other_branch.last_revision())
3023
else:
3024
other_revision_id = revision[-1].as_revision_id(other_branch)
3025
if (revision is not None and len(revision) == 2
3026
and revision[0] is not None):
3027
base_revision_id = revision[0].as_revision_id(base_branch)
3028
else:
3029
base_revision_id = None
3030
# Remember where we merge from
3031
if ((remember or tree.branch.get_submit_branch() is None) and
3032
user_location is not None):
3033
tree.branch.set_submit_branch(other_branch.base)
3034
_merge_tags_if_possible(other_branch, tree.branch)
3035
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3036
other_revision_id, base_revision_id, other_branch, base_branch)
3037
if other_path != '':
3038
allow_pending = False
3039
merger.interesting_files = [other_path]
3040
else:
3041
allow_pending = True
3042
return merger, allow_pending
3043
3044
def _select_branch_location(self, tree, user_location, revision=None,
3045
index=None):
3046
"""Select a branch location, according to possible inputs.
3047
3048
If provided, branches from ``revision`` are preferred. (Both
3049
``revision`` and ``index`` must be supplied.)
3050
3051
Otherwise, the ``location`` parameter is used. If it is None, then the
3052
``submit`` or ``parent`` location is used, and a note is printed.
3053
3054
:param tree: The working tree to select a branch for merging into
3055
:param location: The location entered by the user
3056
:param revision: The revision parameter to the command
3057
:param index: The index to use for the revision parameter. Negative
3058
indices are permitted.
3059
:return: (selected_location, user_location). The default location
3060
will be the user-entered location.
3061
"""
3062
if (revision is not None and index is not None
3063
and revision[index] is not None):
3064
branch = revision[index].get_branch()
3065
if branch is not None:
3066
return branch, branch
3067
if user_location is None:
3068
location = self._get_remembered(tree, 'Merging from')
3069
else:
3070
location = user_location
3071
return location, user_location
3072
3073
def _get_remembered(self, tree, verb_string):
3074
"""Use tree.branch's parent if none was supplied.
3075
3076
Report if the remembered location was used.
3077
"""
3078
stored_location = tree.branch.get_submit_branch()
3079
stored_location_type = "submit"
3080
if stored_location is None:
3081
stored_location = tree.branch.get_parent()
3082
stored_location_type = "parent"
3083
mutter("%s", stored_location)
3084
if stored_location is None:
3085
raise errors.BzrCommandError("No location specified or remembered")
3086
display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
3087
note(u"%s remembered %s location %s", verb_string,
3088
stored_location_type, display_url)
3089
return stored_location
2028
except bzrlib.errors.AmbiguousBase, e:
2029
m = ("sorry, bzr can't determine the right merge base yet\n"
2030
"candidates are:\n "
2031
+ "\n ".join(e.bases)
2032
+ "\n"
2033
"please specify an explicit base with -r,\n"
2034
"and (if you want) report this to the bzr developers\n")
2035
log_error(m)
3090
2036
3091
2037
3092
2038
class cmd_remerge(Command):
3100
2046
merge. The difference is that remerge can (only) be run when there is a
3101
2047
pending merge, and it lets you specify particular files.
3102
2048
3103
:Examples:
2049
Examples:
2050
$ bzr remerge --show-base
3104
2051
Re-do the merge of all conflicted files, and show the base text in
3105
conflict regions, in addition to the usual THIS and OTHER texts::
3106
3107
bzr remerge --show-base
2052
conflict regions, in addition to the usual THIS and OTHER texts.
3108
2053
2054
$ bzr remerge --merge-type weave --reprocess foobar
3109
2055
Re-do the merge of "foobar", using the weave merge algorithm, with
3110
additional processing to reduce the size of conflict regions::
3111
3112
bzr remerge --merge-type weave --reprocess foobar
3113
"""
2056
additional processing to reduce the size of conflict regions.
2057
2058
The following merge types are available:"""
3114
2059
takes_args = ['file*']
3115
takes_options = [
3116
'merge-type',
3117
'reprocess',
3118
Option('show-base',
3119
help="Show base revision text in conflicts."),
3120
]
2060
takes_options = ['merge-type', 'reprocess',
2061
Option('show-base', help="Show base revision text in "
2062
"conflicts")]
2063
2064
def help(self):
2065
from merge import merge_type_help
2066
from inspect import getdoc
2067
return getdoc(self) + '\n' + merge_type_help()
3121
2068
3122
2069
def run(self, file_list=None, merge_type=None, show_base=False,
3123
2070
reprocess=False):
2071
from bzrlib.merge import merge_inner, transform_tree
3124
2072
if merge_type is None:
3125
merge_type = _mod_merge.Merge3Merger
2073
merge_type = Merge3Merger
3126
2074
tree, file_list = tree_files(file_list)
3127
2075
tree.lock_write()
3128
2076
try:
3129
parents = tree.get_parent_ids()
3130
if len(parents) != 2:
3131
raise errors.BzrCommandError("Sorry, remerge only works after normal"
3132
" merges. Not cherrypicking or"
3133
" multi-merges.")
2077
pending_merges = tree.pending_merges()
2078
if len(pending_merges) != 1:
2079
raise BzrCommandError("Sorry, remerge only works after normal"
2080
+ " merges. Not cherrypicking or"
2081
+ "multi-merges.")
3134
2082
repository = tree.branch.repository
2083
base_revision = common_ancestor(tree.branch.last_revision(),
2084
pending_merges[0], repository)
2085
base_tree = repository.revision_tree(base_revision)
2086
other_tree = repository.revision_tree(pending_merges[0])
3135
2087
interesting_ids = None
3136
new_conflicts = []
3137
conflicts = tree.conflicts()
3138
2088
if file_list is not None:
3139
2089
interesting_ids = set()
3140
2090
for filename in file_list:
3141
2091
file_id = tree.path2id(filename)
3142
2092
if file_id is None:
3143
raise errors.NotVersionedError(filename)
2093
raise NotVersionedError(filename)
3144
2094
interesting_ids.add(file_id)
3145
2095
if tree.kind(file_id) != "directory":
3146
2096
continue
3147
2097
3148
2098
for name, ie in tree.inventory.iter_entries(file_id):
3149
2099
interesting_ids.add(ie.file_id)
3150
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2100
transform_tree(tree, tree.basis_tree(), interesting_ids)
2101
if file_list is None:
2102
restore_files = list(tree.iter_conflicts())
3151
2103
else:
3152
# Remerge only supports resolving contents conflicts
3153
allowed_conflicts = ('text conflict', 'contents conflict')
3154
restore_files = [c.path for c in conflicts
3155
if c.typestring in allowed_conflicts]
3156
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
3157
tree.set_conflicts(ConflictList(new_conflicts))
3158
if file_list is not None:
3159
2104
restore_files = file_list
3160
2105
for filename in restore_files:
3161
2106
try:
3162
2107
restore(tree.abspath(filename))
3163
except errors.NotConflicted:
2108
except NotConflicted:
3164
2109
pass
3165
# Disable pending merges, because the file texts we are remerging
3166
# have not had those merges performed. If we use the wrong parents
3167
# list, we imply that the working tree text has seen and rejected
3168
# all the changes from the other tree, when in fact those changes
3169
# have not yet been seen.
3170
pb = ui.ui_factory.nested_progress_bar()
3171
tree.set_parent_ids(parents[:1])
3172
try:
3173
merger = _mod_merge.Merger.from_revision_ids(pb,
3174
tree, parents[1])
3175
merger.interesting_ids = interesting_ids
3176
merger.merge_type = merge_type
3177
merger.show_base = show_base
3178
merger.reprocess = reprocess
3179
conflicts = merger.do_merge()
3180
finally:
3181
tree.set_parent_ids(parents)
3182
pb.finished()
2110
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2111
this_tree=tree,
2112
interesting_ids = interesting_ids,
2113
other_rev_id=pending_merges[0],
2114
merge_type=merge_type,
2115
show_base=show_base,
2116
reprocess=reprocess)
3183
2117
finally:
3184
2118
tree.unlock()
3185
2119
if conflicts > 0:
3187
2121
else:
3188
2122
return 0
3189
2123
3190
3191
2124
class cmd_revert(Command):
3192
"""Revert files to a previous revision.
3193
3194
Giving a list of files will revert only those files. Otherwise, all files
3195
will be reverted. If the revision is not specified with '--revision', the
3196
last committed revision is used.
3197
3198
To remove only some changes, without reverting to a prior version, use
3199
merge instead. For example, "merge . --revision -2..-3" will remove the
3200
changes introduced by -2, without affecting the changes introduced by -1.
3201
Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
3202
3203
By default, any files that have been manually changed will be backed up
3204
first. (Files changed only by merge are not backed up.) Backup files have
3205
'.~#~' appended to their name, where # is a number.
3206
3207
When you provide files, you can use their current pathname or the pathname
3208
from the target revision. So you can use revert to "undelete" a file by
3209
name. If you name a directory, all the contents of that directory will be
3210
reverted.
3211
3212
Any files that have been newly added since that revision will be deleted,
3213
with a backup kept if appropriate. Directories containing unknown files
3214
will not be deleted.
3215
3216
The working tree contains a list of pending merged revisions, which will
3217
be included as parents in the next commit. Normally, revert clears that
3218
list as well as reverting the files. If any files are specified, revert
3219
leaves the pending merge list alone and reverts only the files. Use "bzr
3220
revert ." in the tree root to revert all files but keep the merge record,
3221
and "bzr revert --forget-merges" to clear the pending merge list without
3222
reverting any files.
2125
"""Reverse all changes since the last commit.
2126
2127
Only versioned files are affected. Specify filenames to revert only
2128
those files. By default, any files that are changed will be backed up
2129
first. Backup files have a '~' appended to their name.
3223
2130
"""
3224
3225
_see_also = ['cat', 'export']
3226
takes_options = [
3227
'revision',
3228
Option('no-backup', "Do not save backups of reverted files."),
3229
Option('forget-merges',
3230
'Remove pending merge marker, without changing any files.'),
3231
]
2131
takes_options = ['revision', 'no-backup']
3232
2132
takes_args = ['file*']
2133
aliases = ['merge-revert']
3233
2134
3234
def run(self, revision=None, no_backup=False, file_list=None,
3235
forget_merges=None):
2135
def run(self, revision=None, no_backup=False, file_list=None):
2136
from bzrlib.commands import parse_spec
2137
if file_list is not None:
2138
if len(file_list) == 0:
2139
raise BzrCommandError("No files specified")
2140
else:
2141
file_list = []
2142
3236
2143
tree, file_list = tree_files(file_list)
3237
if forget_merges:
3238
tree.set_parent_ids(tree.get_parent_ids()[:1])
3239
else:
3240
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
3241
3242
@staticmethod
3243
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
3244
2144
if revision is None:
2145
# FIXME should be tree.last_revision
3245
2146
rev_id = tree.last_revision()
3246
2147
elif len(revision) != 1:
3247
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
2148
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
3248
2149
else:
3249
rev_id = revision[0].as_revision_id(tree.branch)
3250
pb = ui.ui_factory.nested_progress_bar()
2150
rev_id = revision[0].in_history(tree.branch).rev_id
2151
pb = bzrlib.ui.ui_factory.nested_progress_bar()
3251
2152
try:
3252
tree.revert(file_list,
2153
tree.revert(file_list,
3253
2154
tree.branch.repository.revision_tree(rev_id),
3254
not no_backup, pb, report_changes=True)
2155
not no_backup, pb)
3255
2156
finally:
3256
2157
pb.finished()
3257
2158
3258
2159
3259
2160
class cmd_assert_fail(Command):
3260
2161
"""Test reporting of assertion failures"""
3261
# intended just for use in testing
3262
3263
2162
hidden = True
3264
3265
2163
def run(self):
3266
raise AssertionError("always fails")
2164
assert False, "always fails"
3267
2165
3268
2166
3269
2167
class cmd_help(Command):
3270
2168
"""Show help on a command or other topic.
3271
"""
3272
2169
3273
_see_also = ['topics']
3274
takes_options = [
3275
Option('long', 'Show help on all commands.'),
3276
]
2170
For a list of all available commands, say 'bzr help commands'."""
2171
takes_options = [Option('long', 'show help on all commands')]
3277
2172
takes_args = ['topic?']
3278
2173
aliases = ['?', '--help', '-?', '-h']
3279
2174
3280
2175
@display_command
3281
2176
def run(self, topic=None, long=False):
3282
import bzrlib.help
2177
import help
3283
2178
if topic is None and long:
3284
2179
topic = "commands"
3285
bzrlib.help.help(topic)
2180
help.help(topic)
3286
2181
3287
2182
3288
2183
class cmd_shell_complete(Command):
3289
2184
"""Show appropriate completions for context.
3290
2185
3291
For a list of all available commands, say 'bzr shell-complete'.
3292
"""
2186
For a list of all available commands, say 'bzr shell-complete'."""
3293
2187
takes_args = ['context?']
3294
2188
aliases = ['s-c']
3295
2189
hidden = True
3300
2194
shellcomplete.shellcomplete(context)
3301
2195
3302
2196
2197
class cmd_fetch(Command):
2198
"""Copy in history from another branch but don't merge it.
2199
2200
This is an internal method used for pull and merge."""
2201
hidden = True
2202
takes_args = ['from_branch', 'to_branch']
2203
def run(self, from_branch, to_branch):
2204
from bzrlib.fetch import Fetcher
2205
from bzrlib.branch import Branch
2206
from_b = Branch.open(from_branch)
2207
to_b = Branch.open(to_branch)
2208
Fetcher(to_b, from_b)
2209
2210
3303
2211
class cmd_missing(Command):
3304
2212
"""Show unmerged/unpulled revisions between two branches.
3305
3306
OTHER_BRANCH may be local or remote.
3307
"""
3308
2213
3309
_see_also = ['merge', 'pull']
2214
OTHER_BRANCH may be local or remote."""
3310
2215
takes_args = ['other_branch?']
3311
takes_options = [
3312
Option('reverse', 'Reverse the order of revisions.'),
3313
Option('mine-only',
3314
'Display changes in the local branch only.'),
3315
Option('this' , 'Same as --mine-only.'),
3316
Option('theirs-only',
3317
'Display changes in the remote branch only.'),
3318
Option('other', 'Same as --theirs-only.'),
3319
'log-format',
3320
'show-ids',
3321
'verbose'
3322
]
3323
encoding_type = 'replace'
2216
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2217
Option('mine-only',
2218
'Display changes in the local branch only'),
2219
Option('theirs-only',
2220
'Display changes in the remote branch only'),
2221
'log-format',
2222
'line',
2223
'long',
2224
'short',
2225
'show-ids',
2226
'verbose'
2227
]
3324
2228
3325
@display_command
3326
2229
def run(self, other_branch=None, reverse=False, mine_only=False,
3327
2230
theirs_only=False, log_format=None, long=False, short=False, line=False,
3328
show_ids=False, verbose=False, this=False, other=False):
3329
from bzrlib.missing import find_unmerged, iter_log_revisions
3330
3331
if this:
3332
mine_only = this
3333
if other:
3334
theirs_only = other
3335
# TODO: We should probably check that we don't have mine-only and
3336
# theirs-only set, but it gets complicated because we also have
3337
# this and other which could be used.
3338
restrict = 'all'
3339
if mine_only:
3340
restrict = 'local'
3341
elif theirs_only:
3342
restrict = 'remote'
3343
3344
local_branch = Branch.open_containing(u".")[0]
2231
show_ids=False, verbose=False):
2232
from bzrlib.missing import find_unmerged, iter_log_data
2233
from bzrlib.log import log_formatter
2234
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
3345
2235
parent = local_branch.get_parent()
3346
2236
if other_branch is None:
3347
2237
other_branch = parent
3348
2238
if other_branch is None:
3349
raise errors.BzrCommandError("No peer location known"
3350
" or specified.")
3351
display_url = urlutils.unescape_for_display(parent,
3352
self.outf.encoding)
3353
self.outf.write("Using saved parent location: "
3354
+ display_url + "\n")
3355
3356
remote_branch = Branch.open(other_branch)
2239
raise BzrCommandError("No missing location known or specified.")
2240
print "Using last location: " + local_branch.get_parent()
2241
remote_branch = bzrlib.branch.Branch.open(other_branch)
3357
2242
if remote_branch.base == local_branch.base:
3358
2243
remote_branch = local_branch
3359
2244
local_branch.lock_read()
3360
2245
try:
3361
2246
remote_branch.lock_read()
3362
2247
try:
3363
local_extra, remote_extra = find_unmerged(
3364
local_branch, remote_branch, restrict)
3365
3366
if log_format is None:
3367
registry = log.log_formatter_registry
3368
log_format = registry.get_default(local_branch)
3369
lf = log_format(to_file=self.outf,
3370
show_ids=show_ids,
3371
show_timezone='original')
2248
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2249
if (log_format == None):
2250
default = bzrlib.config.BranchConfig(local_branch).log_format()
2251
log_format = get_log_format(long=long, short=short, line=line, default=default)
2252
lf = log_formatter(log_format, sys.stdout,
2253
show_ids=show_ids,
2254
show_timezone='original')
3372
2255
if reverse is False:
3373
if local_extra is not None:
3374
local_extra.reverse()
3375
if remote_extra is not None:
3376
remote_extra.reverse()
3377
3378
status_code = 0
2256
local_extra.reverse()
2257
remote_extra.reverse()
3379
2258
if local_extra and not theirs_only:
3380
self.outf.write("You have %d extra revision(s):\n" %
3381
len(local_extra))
3382
for revision in iter_log_revisions(local_extra,
3383
local_branch.repository,
3384
verbose):
3385
lf.log_revision(revision)
2259
print "You have %d extra revision(s):" % len(local_extra)
2260
for data in iter_log_data(local_extra, local_branch.repository,
2261
verbose):
2262
lf.show(*data)
3386
2263
printed_local = True
3387
status_code = 1
3388
2264
else:
3389
2265
printed_local = False
3390
3391
2266
if remote_extra and not mine_only:
3392
2267
if printed_local is True:
3393
self.outf.write("\n\n\n")
3394
self.outf.write("You are missing %d revision(s):\n" %
3395
len(remote_extra))
3396
for revision in iter_log_revisions(remote_extra,
3397
remote_branch.repository,
3398
verbose):
3399
lf.log_revision(revision)
2268
print "\n\n"
2269
print "You are missing %d revision(s):" % len(remote_extra)
2270
for data in iter_log_data(remote_extra, remote_branch.repository,
2271
verbose):
2272
lf.show(*data)
2273
if not remote_extra and not local_extra:
2274
status_code = 0
2275
print "Branches are up to date."
2276
else:
3400
2277
status_code = 1
3401
3402
if mine_only and not local_extra:
3403
# We checked local, and found nothing extra
3404
self.outf.write('This branch is up to date.\n')
3405
elif theirs_only and not remote_extra:
3406
# We checked remote, and found nothing extra
3407
self.outf.write('Other branch is up to date.\n')
3408
elif not (mine_only or theirs_only or local_extra or
3409
remote_extra):
3410
# We checked both branches, and neither one had extra
3411
# revisions
3412
self.outf.write("Branches are up to date.\n")
3413
2278
finally:
3414
2279
remote_branch.unlock()
3415
2280
finally:
3419
2284
try:
3420
2285
# handle race conditions - a parent might be set while we run.
3421
2286
if local_branch.get_parent() is None:
3422
local_branch.set_parent(remote_branch.base)
2287
local_branch.set_parent(other_branch)
3423
2288
finally:
3424
2289
local_branch.unlock()
3425
2290
return status_code
3426
2291
3427
2292
3428
class cmd_pack(Command):
3429
"""Compress the data within a repository."""
3430
3431
_see_also = ['repositories']
3432
takes_args = ['branch_or_repo?']
3433
3434
def run(self, branch_or_repo='.'):
3435
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
3436
try:
3437
branch = dir.open_branch()
3438
repository = branch.repository
3439
except errors.NotBranchError:
3440
repository = dir.open_repository()
3441
repository.pack()
3442
3443
3444
2293
class cmd_plugins(Command):
3445
"""List the installed plugins.
3446
3447
This command displays the list of installed plugins including
3448
version of plugin and a short description of each.
3449
3450
--verbose shows the path where each plugin is located.
3451
3452
A plugin is an external component for Bazaar that extends the
3453
revision control system, by adding or replacing code in Bazaar.
3454
Plugins can do a variety of things, including overriding commands,
3455
adding new commands, providing additional network transports and
3456
customizing log output.
3457
3458
See the Bazaar web site, http://bazaar-vcs.org, for further
3459
information on plugins including where to find them and how to
3460
install them. Instructions are also provided there on how to
3461
write new plugins using the Python programming language.
3462
"""
3463
takes_options = ['verbose']
3464
2294
"""List plugins"""
2295
hidden = True
3465
2296
@display_command
3466
def run(self, verbose=False):
2297
def run(self):
3467
2298
import bzrlib.plugin
3468
2299
from inspect import getdoc
3469
result = []
3470
for name, plugin in bzrlib.plugin.plugins().items():
3471
version = plugin.__version__
3472
if version == 'unknown':
3473
version = ''
3474
name_ver = '%s %s' % (name, version)
3475
d = getdoc(plugin.module)
2300
for name, plugin in bzrlib.plugin.all_plugins().items():
2301
if hasattr(plugin, '__path__'):
2302
print plugin.__path__[0]
2303
elif hasattr(plugin, '__file__'):
2304
print plugin.__file__
2305
else:
2306
print `plugin`
2307
2308
d = getdoc(plugin)
3476
2309
if d:
3477
doc = d.split('\n')[0]
3478
else:
3479
doc = '(no description)'
3480
result.append((name_ver, doc, plugin.path()))
3481
for name_ver, doc, path in sorted(result):
3482
print name_ver
3483
print ' ', doc
3484
if verbose:
3485
print ' ', path
3486
print
2310
print '\t', d.split('\n')[0]
3487
2311
3488
2312
3489
2313
class cmd_testament(Command):
3490
2314
"""Show testament (signing-form) of a revision."""
3491
takes_options = [
3492
'revision',
3493
Option('long', help='Produce long-format testament.'),
3494
Option('strict',
3495
help='Produce a strict-format testament.')]
2315
takes_options = ['revision', 'long']
3496
2316
takes_args = ['branch?']
3497
2317
@display_command
3498
def run(self, branch=u'.', revision=None, long=False, strict=False):
3499
from bzrlib.testament import Testament, StrictTestament
3500
if strict is True:
3501
testament_class = StrictTestament
3502
else:
3503
testament_class = Testament
3504
if branch == '.':
3505
b = Branch.open_containing(branch)[0]
3506
else:
3507
b = Branch.open(branch)
2318
def run(self, branch=u'.', revision=None, long=False):
2319
from bzrlib.testament import Testament
2320
b = WorkingTree.open_containing(branch)[0].branch
3508
2321
b.lock_read()
3509
2322
try:
3510
2323
if revision is None:
3511
2324
rev_id = b.last_revision()
3512
2325
else:
3513
rev_id = revision[0].as_revision_id(b)
3514
t = testament_class.from_revision(b.repository, rev_id)
2326
rev_id = revision[0].in_history(b).rev_id
2327
t = Testament.from_revision(b.repository, rev_id)
3515
2328
if long:
3516
2329
sys.stdout.writelines(t.as_text_lines())
3517
2330
else:
3532
2345
# TODO: annotate directories; showing when each file was last changed
3533
2346
# TODO: if the working copy is modified, show annotations on that
3534
2347
# with new uncommitted lines marked
3535
aliases = ['ann', 'blame', 'praise']
2348
aliases = ['blame', 'praise']
3536
2349
takes_args = ['filename']
3537
takes_options = [Option('all', help='Show annotations on all lines.'),
3538
Option('long', help='Show commit date in annotations.'),
3539
'revision',
3540
'show-ids',
2350
takes_options = [Option('all', help='show annotations on all lines'),
2351
Option('long', help='show date in annotations'),
2352
'revision'
3541
2353
]
3542
encoding_type = 'exact'
3543
2354
3544
2355
@display_command
3545
def run(self, filename, all=False, long=False, revision=None,
3546
show_ids=False):
2356
def run(self, filename, all=False, long=False, revision=None):
3547
2357
from bzrlib.annotate import annotate_file
3548
wt, branch, relpath = \
3549
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
3550
if wt is not None:
3551
wt.lock_read()
3552
else:
3553
branch.lock_read()
2358
tree, relpath = WorkingTree.open_containing(filename)
2359
branch = tree.branch
2360
branch.lock_read()
3554
2361
try:
3555
2362
if revision is None:
3556
2363
revision_id = branch.last_revision()
3557
2364
elif len(revision) != 1:
3558
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2365
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
3559
2366
else:
3560
revision_id = revision[0].as_revision_id(branch)
2367
revision_id = revision[0].in_history(branch).rev_id
2368
file_id = tree.inventory.path2id(relpath)
3561
2369
tree = branch.repository.revision_tree(revision_id)
3562
if wt is not None:
3563
file_id = wt.path2id(relpath)
3564
else:
3565
file_id = tree.path2id(relpath)
3566
if file_id is None:
3567
raise errors.NotVersionedError(filename)
3568
2370
file_version = tree.inventory[file_id].revision
3569
annotate_file(branch, file_version, file_id, long, all, self.outf,
3570
show_ids=show_ids)
2371
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
3571
2372
finally:
3572
if wt is not None:
3573
wt.unlock()
3574
else:
3575
branch.unlock()
2373
branch.unlock()
3576
2374
3577
2375
3578
2376
class cmd_re_sign(Command):
3584
2382
takes_options = ['revision']
3585
2383
3586
2384
def run(self, revision_id_list=None, revision=None):
2385
import bzrlib.config as config
2386
import bzrlib.gpg as gpg
3587
2387
if revision_id_list is not None and revision is not None:
3588
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
2388
raise BzrCommandError('You can only supply one of revision_id or --revision')
3589
2389
if revision_id_list is None and revision is None:
3590
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
2390
raise BzrCommandError('You must supply either --revision or a revision_id')
3591
2391
b = WorkingTree.open_containing(u'.')[0].branch
3592
b.lock_write()
3593
try:
3594
return self._run(b, revision_id_list, revision)
3595
finally:
3596
b.unlock()
3597
3598
def _run(self, b, revision_id_list, revision):
3599
import bzrlib.gpg as gpg
3600
gpg_strategy = gpg.GPGStrategy(b.get_config())
2392
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
3601
2393
if revision_id_list is not None:
3602
b.repository.start_write_group()
3603
try:
3604
for revision_id in revision_id_list:
3605
b.repository.sign_revision(revision_id, gpg_strategy)
3606
except:
3607
b.repository.abort_write_group()
3608
raise
3609
else:
3610
b.repository.commit_write_group()
2394
for revision_id in revision_id_list:
2395
b.repository.sign_revision(revision_id, gpg_strategy)
3611
2396
elif revision is not None:
3612
2397
if len(revision) == 1:
3613
2398
revno, rev_id = revision[0].in_history(b)
3614
b.repository.start_write_group()
3615
try:
3616
b.repository.sign_revision(rev_id, gpg_strategy)
3617
except:
3618
b.repository.abort_write_group()
3619
raise
3620
else:
3621
b.repository.commit_write_group()
2399
b.repository.sign_revision(rev_id, gpg_strategy)
3622
2400
elif len(revision) == 2:
3623
2401
# are they both on rh- if so we can walk between them
3624
2402
# might be nice to have a range helper for arbitrary
3628
2406
if to_revid is None:
3629
2407
to_revno = b.revno()
3630
2408
if from_revno is None or to_revno is None:
3631
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
3632
b.repository.start_write_group()
3633
try:
3634
for revno in range(from_revno, to_revno + 1):
3635
b.repository.sign_revision(b.get_rev_id(revno),
3636
gpg_strategy)
3637
except:
3638
b.repository.abort_write_group()
3639
raise
3640
else:
3641
b.repository.commit_write_group()
2409
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2410
for revno in range(from_revno, to_revno + 1):
2411
b.repository.sign_revision(b.get_rev_id(revno),
2412
gpg_strategy)
3642
2413
else:
3643
raise errors.BzrCommandError('Please supply either one revision, or a range.')
2414
raise BzrCommandError('Please supply either one revision, or a range.')
3644
2415
3645
2416
3646
2417
class cmd_bind(Command):
3647
"""Convert the current branch into a checkout of the supplied branch.
2418
"""Bind the current branch to a master branch.
3648
2419
3649
Once converted into a checkout, commits must succeed on the master branch
3650
before they will be applied to the local branch.
2420
After binding, commits must succeed on the master branch
2421
before they are executed on the local one.
3651
2422
"""
3652
2423
3653
_see_also = ['checkouts', 'unbind']
3654
takes_args = ['location?']
2424
takes_args = ['location']
3655
2425
takes_options = []
3656
2426
3657
2427
def run(self, location=None):
3658
2428
b, relpath = Branch.open_containing(u'.')
3659
if location is None:
3660
try:
3661
location = b.get_old_bound_location()
3662
except errors.UpgradeRequired:
3663
raise errors.BzrCommandError('No location supplied. '
3664
'This format does not remember old locations.')
3665
else:
3666
if location is None:
3667
raise errors.BzrCommandError('No location supplied and no '
3668
'previous location known')
3669
2429
b_other = Branch.open(location)
3670
2430
try:
3671
2431
b.bind(b_other)
3672
except errors.DivergedBranches:
3673
raise errors.BzrCommandError('These branches have diverged.'
3674
' Try merging, and then bind again.')
2432
except DivergedBranches:
2433
raise BzrCommandError('These branches have diverged.'
2434
' Try merging, and then bind again.')
3675
2435
3676
2436
3677
2437
class cmd_unbind(Command):
3678
"""Convert the current checkout into a regular branch.
2438
"""Unbind the current branch from its master branch.
3679
2439
3680
After unbinding, the local branch is considered independent and subsequent
3681
commits will be local only.
2440
After unbinding, the local branch is considered independent.
2441
All subsequent commits will be local.
3682
2442
"""
3683
2443
3684
_see_also = ['checkouts', 'bind']
3685
2444
takes_args = []
3686
2445
takes_options = []
3687
2446
3688
2447
def run(self):
3689
2448
b, relpath = Branch.open_containing(u'.')
3690
2449
if not b.unbind():
3691
raise errors.BzrCommandError('Local branch is not bound')
3692
3693
3694
class cmd_uncommit(Command):
2450
raise BzrCommandError('Local branch is not bound')
2451
2452
2453
class cmd_uncommit(bzrlib.commands.Command):
3695
2454
"""Remove the last committed revision.
3696
2455
3697
2456
--verbose will print out what is being removed.
3698
2457
--dry-run will go through all the motions, but not actually
3699
2458
remove anything.
3700
3701
If --revision is specified, uncommit revisions to leave the branch at the
3702
specified revision. For example, "bzr uncommit -r 15" will leave the
3703
branch at revision 15.
3704
3705
Uncommit leaves the working tree ready for a new commit. The only change
3706
it may make is to restore any pending merges that were present before
3707
the commit.
2459
2460
In the future, uncommit will create a changeset, which can then
2461
be re-applied.
3708
2462
"""
3709
2463
3710
2464
# TODO: jam 20060108 Add an option to allow uncommit to remove
3711
# unreferenced information in 'branch-as-repository' branches.
2465
# unreferenced information in 'branch-as-repostory' branches.
3712
2466
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
3713
2467
# information in shared branches as well.
3714
_see_also = ['commit']
3715
2468
takes_options = ['verbose', 'revision',
3716
Option('dry-run', help='Don\'t actually make changes.'),
3717
Option('force', help='Say yes to all questions.'),
3718
Option('local',
3719
help="Only remove the commits from the local branch"
3720
" when in a checkout."
3721
),
3722
]
2469
Option('dry-run', help='Don\'t actually make changes'),
2470
Option('force', help='Say yes to all questions.')]
3723
2471
takes_args = ['location?']
3724
2472
aliases = []
3725
encoding_type = 'replace'
3726
2473
3727
def run(self, location=None,
2474
def run(self, location=None,
3728
2475
dry_run=False, verbose=False,
3729
revision=None, force=False, local=False):
2476
revision=None, force=False):
2477
from bzrlib.branch import Branch
2478
from bzrlib.log import log_formatter
2479
import sys
2480
from bzrlib.uncommit import uncommit
2481
3730
2482
if location is None:
3731
2483
location = u'.'
3732
2484
control, relpath = bzrdir.BzrDir.open_containing(location)
3737
2489
tree = None
3738
2490
b = control.open_branch()
3739
2491
3740
if tree is not None:
3741
tree.lock_write()
3742
else:
3743
b.lock_write()
3744
try:
3745
return self._run(b, tree, dry_run, verbose, revision, force,
3746
local=local)
3747
finally:
3748
if tree is not None:
3749
tree.unlock()
3750
else:
3751
b.unlock()
3752
3753
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
3754
from bzrlib.log import log_formatter, show_log
3755
from bzrlib.uncommit import uncommit
3756
3757
last_revno, last_rev_id = b.last_revision_info()
3758
3759
rev_id = None
3760
2492
if revision is None:
3761
revno = last_revno
3762
rev_id = last_rev_id
2493
revno = b.revno()
2494
rev_id = b.last_revision()
3763
2495
else:
3764
# 'bzr uncommit -r 10' actually means uncommit
3765
# so that the final tree is at revno 10.
3766
# but bzrlib.uncommit.uncommit() actually uncommits
3767
# the revisions that are supplied.
3768
# So we need to offset it by one
3769
revno = revision[0].in_history(b).revno + 1
3770
if revno <= last_revno:
3771
rev_id = b.get_rev_id(revno)
3772
3773
if rev_id is None or _mod_revision.is_null(rev_id):
3774
self.outf.write('No revisions to uncommit.\n')
3775
return 1
3776
3777
lf = log_formatter('short',
3778
to_file=self.outf,
3779
show_timezone='original')
3780
3781
show_log(b,
3782
lf,
3783
verbose=False,
3784
direction='forward',
3785
start_revision=revno,
3786
end_revision=last_revno)
2496
revno, rev_id = revision[0].in_history(b)
2497
if rev_id is None:
2498
print 'No revisions to uncommit.'
2499
2500
for r in range(revno, b.revno()+1):
2501
rev_id = b.get_rev_id(r)
2502
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2503
lf.show(r, b.repository.get_revision(rev_id), None)
3787
2504
3788
2505
if dry_run:
3789
2506
print 'Dry-run, pretending to remove the above revisions.'
3797
2514
print 'Canceled'
3798
2515
return 0
3799
2516
3800
mutter('Uncommitting from {%s} to {%s}',
3801
last_rev_id, rev_id)
3802
2517
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
3803
revno=revno, local=local)
3804
note('You can restore the old tip by running:\n'
3805
' bzr pull . -r revid:%s', last_rev_id)
2518
revno=revno)
3806
2519
3807
2520
3808
2521
class cmd_break_lock(Command):
3813
2526
3814
2527
You can get information on what locks are open via the 'bzr info' command.
3815
2528
3816
:Examples:
2529
example:
3817
2530
bzr break-lock
3818
2531
"""
3819
2532
takes_args = ['location?']
3828
2541
pass
3829
2542
3830
2543
3831
class cmd_wait_until_signalled(Command):
3832
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
3833
3834
This just prints a line to signal when it is ready, then blocks on stdin.
3835
"""
3836
3837
hidden = True
3838
3839
def run(self):
3840
sys.stdout.write("running\n")
3841
sys.stdout.flush()
3842
sys.stdin.readline()
3843
3844
3845
class cmd_serve(Command):
3846
"""Run the bzr server."""
3847
3848
aliases = ['server']
3849
3850
takes_options = [
3851
Option('inet',
3852
help='Serve on stdin/out for use from inetd or sshd.'),
3853
Option('port',
3854
help='Listen for connections on nominated port of the form '
3855
'[hostname:]portnumber. Passing 0 as the port number will '
3856
'result in a dynamically allocated port. The default port is '
3857
'4155.',
3858
type=str),
3859
Option('directory',
3860
help='Serve contents of this directory.',
3861
type=unicode),
3862
Option('allow-writes',
3863
help='By default the server is a readonly server. Supplying '
3864
'--allow-writes enables write access to the contents of '
3865
'the served directory and below.'
3866
),
3867
]
3868
3869
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3870
from bzrlib import lockdir
3871
from bzrlib.smart import medium, server
3872
from bzrlib.transport import get_transport
3873
from bzrlib.transport.chroot import ChrootServer
3874
if directory is None:
3875
directory = os.getcwd()
3876
url = urlutils.local_path_to_url(directory)
3877
if not allow_writes:
3878
url = 'readonly+' + url
3879
chroot_server = ChrootServer(get_transport(url))
3880
chroot_server.setUp()
3881
t = get_transport(chroot_server.get_url())
3882
if inet:
3883
smart_server = medium.SmartServerPipeStreamMedium(
3884
sys.stdin, sys.stdout, t)
3885
else:
3886
host = medium.BZR_DEFAULT_INTERFACE
3887
if port is None:
3888
port = medium.BZR_DEFAULT_PORT
3889
else:
3890
if ':' in port:
3891
host, port = port.split(':')
3892
port = int(port)
3893
smart_server = server.SmartTCPServer(t, host=host, port=port)
3894
print 'listening on port: ', smart_server.port
3895
sys.stdout.flush()
3896
# for the duration of this server, no UI output is permitted.
3897
# note that this may cause problems with blackbox tests. This should
3898
# be changed with care though, as we dont want to use bandwidth sending
3899
# progress over stderr to smart server clients!
3900
old_factory = ui.ui_factory
3901
old_lockdir_timeout = lockdir._DEFAULT_TIMEOUT_SECONDS
3902
try:
3903
ui.ui_factory = ui.SilentUIFactory()
3904
lockdir._DEFAULT_TIMEOUT_SECONDS = 0
3905
smart_server.serve()
3906
finally:
3907
ui.ui_factory = old_factory
3908
lockdir._DEFAULT_TIMEOUT_SECONDS = old_lockdir_timeout
3909
3910
3911
class cmd_join(Command):
3912
"""Combine a subtree into its containing tree.
3913
3914
This command is for experimental use only. It requires the target tree
3915
to be in dirstate-with-subtree format, which cannot be converted into
3916
earlier formats.
3917
3918
The TREE argument should be an independent tree, inside another tree, but
3919
not part of it. (Such trees can be produced by "bzr split", but also by
3920
running "bzr branch" with the target inside a tree.)
3921
3922
The result is a combined tree, with the subtree no longer an independant
3923
part. This is marked as a merge of the subtree into the containing tree,
3924
and all history is preserved.
3925
3926
If --reference is specified, the subtree retains its independence. It can
3927
be branched by itself, and can be part of multiple projects at the same
3928
time. But operations performed in the containing tree, such as commit
3929
and merge, will recurse into the subtree.
3930
"""
3931
3932
_see_also = ['split']
3933
takes_args = ['tree']
3934
takes_options = [
3935
Option('reference', help='Join by reference.'),
3936
]
3937
hidden = True
3938
3939
def run(self, tree, reference=False):
3940
sub_tree = WorkingTree.open(tree)
3941
parent_dir = osutils.dirname(sub_tree.basedir)
3942
containing_tree = WorkingTree.open_containing(parent_dir)[0]
3943
repo = containing_tree.branch.repository
3944
if not repo.supports_rich_root():
3945
raise errors.BzrCommandError(
3946
"Can't join trees because %s doesn't support rich root data.\n"
3947
"You can use bzr upgrade on the repository."
3948
% (repo,))
3949
if reference:
3950
try:
3951
containing_tree.add_reference(sub_tree)
3952
except errors.BadReferenceTarget, e:
3953
# XXX: Would be better to just raise a nicely printable
3954
# exception from the real origin. Also below. mbp 20070306
3955
raise errors.BzrCommandError("Cannot join %s. %s" %
3956
(tree, e.reason))
3957
else:
3958
try:
3959
containing_tree.subsume(sub_tree)
3960
except errors.BadSubsumeSource, e:
3961
raise errors.BzrCommandError("Cannot join %s. %s" %
3962
(tree, e.reason))
3963
3964
3965
class cmd_split(Command):
3966
"""Split a subdirectory of a tree into a separate tree.
3967
3968
This command will produce a target tree in a format that supports
3969
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
3970
converted into earlier formats like 'dirstate-tags'.
3971
3972
The TREE argument should be a subdirectory of a working tree. That
3973
subdirectory will be converted into an independent tree, with its own
3974
branch. Commits in the top-level tree will not apply to the new subtree.
3975
"""
3976
3977
# join is not un-hidden yet
3978
#_see_also = ['join']
3979
takes_args = ['tree']
3980
3981
def run(self, tree):
3982
containing_tree, subdir = WorkingTree.open_containing(tree)
3983
sub_id = containing_tree.path2id(subdir)
3984
if sub_id is None:
3985
raise errors.NotVersionedError(subdir)
3986
try:
3987
containing_tree.extract(sub_id)
3988
except errors.RootNotRich:
3989
raise errors.UpgradeRequired(containing_tree.branch.base)
3990
3991
3992
class cmd_merge_directive(Command):
3993
"""Generate a merge directive for auto-merge tools.
3994
3995
A directive requests a merge to be performed, and also provides all the
3996
information necessary to do so. This means it must either include a
3997
revision bundle, or the location of a branch containing the desired
3998
revision.
3999
4000
A submit branch (the location to merge into) must be supplied the first
4001
time the command is issued. After it has been supplied once, it will
4002
be remembered as the default.
4003
4004
A public branch is optional if a revision bundle is supplied, but required
4005
if --diff or --plain is specified. It will be remembered as the default
4006
after the first use.
4007
"""
4008
4009
takes_args = ['submit_branch?', 'public_branch?']
4010
4011
hidden = True
4012
4013
_see_also = ['send']
4014
4015
takes_options = [
4016
RegistryOption.from_kwargs('patch-type',
4017
'The type of patch to include in the directive.',
4018
title='Patch type',
4019
value_switches=True,
4020
enum_switch=False,
4021
bundle='Bazaar revision bundle (default).',
4022
diff='Normal unified diff.',
4023
plain='No patch, just directive.'),
4024
Option('sign', help='GPG-sign the directive.'), 'revision',
4025
Option('mail-to', type=str,
4026
help='Instead of printing the directive, email to this address.'),
4027
Option('message', type=str, short_name='m',
4028
help='Message to use when committing this merge.')
4029
]
4030
4031
encoding_type = 'exact'
4032
4033
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
4034
sign=False, revision=None, mail_to=None, message=None):
4035
from bzrlib.revision import ensure_null, NULL_REVISION
4036
include_patch, include_bundle = {
4037
'plain': (False, False),
4038
'diff': (True, False),
4039
'bundle': (True, True),
4040
}[patch_type]
4041
branch = Branch.open('.')
4042
stored_submit_branch = branch.get_submit_branch()
4043
if submit_branch is None:
4044
submit_branch = stored_submit_branch
4045
else:
4046
if stored_submit_branch is None:
4047
branch.set_submit_branch(submit_branch)
4048
if submit_branch is None:
4049
submit_branch = branch.get_parent()
4050
if submit_branch is None:
4051
raise errors.BzrCommandError('No submit branch specified or known')
4052
4053
stored_public_branch = branch.get_public_branch()
4054
if public_branch is None:
4055
public_branch = stored_public_branch
4056
elif stored_public_branch is None:
4057
branch.set_public_branch(public_branch)
4058
if not include_bundle and public_branch is None:
4059
raise errors.BzrCommandError('No public branch specified or'
4060
' known')
4061
base_revision_id = None
4062
if revision is not None:
4063
if len(revision) > 2:
4064
raise errors.BzrCommandError('bzr merge-directive takes '
4065
'at most two one revision identifiers')
4066
revision_id = revision[-1].as_revision_id(branch)
4067
if len(revision) == 2:
4068
base_revision_id = revision[0].as_revision_id(branch)
4069
else:
4070
revision_id = branch.last_revision()
4071
revision_id = ensure_null(revision_id)
4072
if revision_id == NULL_REVISION:
4073
raise errors.BzrCommandError('No revisions to bundle.')
4074
directive = merge_directive.MergeDirective2.from_objects(
4075
branch.repository, revision_id, time.time(),
4076
osutils.local_time_offset(), submit_branch,
4077
public_branch=public_branch, include_patch=include_patch,
4078
include_bundle=include_bundle, message=message,
4079
base_revision_id=base_revision_id)
4080
if mail_to is None:
4081
if sign:
4082
self.outf.write(directive.to_signed(branch))
4083
else:
4084
self.outf.writelines(directive.to_lines())
4085
else:
4086
message = directive.to_email(mail_to, branch, sign)
4087
s = SMTPConnection(branch.get_config())
4088
s.send_email(message)
4089
4090
4091
class cmd_send(Command):
4092
"""Mail or create a merge-directive for submiting changes.
4093
4094
A merge directive provides many things needed for requesting merges:
4095
4096
* A machine-readable description of the merge to perform
4097
4098
* An optional patch that is a preview of the changes requested
4099
4100
* An optional bundle of revision data, so that the changes can be applied
4101
directly from the merge directive, without retrieving data from a
4102
branch.
4103
4104
If --no-bundle is specified, then public_branch is needed (and must be
4105
up-to-date), so that the receiver can perform the merge using the
4106
public_branch. The public_branch is always included if known, so that
4107
people can check it later.
4108
4109
The submit branch defaults to the parent, but can be overridden. Both
4110
submit branch and public branch will be remembered if supplied.
4111
4112
If a public_branch is known for the submit_branch, that public submit
4113
branch is used in the merge instructions. This means that a local mirror
4114
can be used as your actual submit branch, once you have set public_branch
4115
for that mirror.
4116
4117
Mail is sent using your preferred mail program. This should be transparent
4118
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
4119
If the preferred client can't be found (or used), your editor will be used.
4120
4121
To use a specific mail program, set the mail_client configuration option.
4122
(For Thunderbird 1.5, this works around some bugs.) Supported values for
4123
specific clients are "evolution", "kmail", "mutt", and "thunderbird";
4124
generic options are "default", "editor", "emacsclient", "mapi", and
4125
"xdg-email". Plugins may also add supported clients.
4126
4127
If mail is being sent, a to address is required. This can be supplied
4128
either on the commandline, by setting the submit_to configuration
4129
option in the branch itself or the child_submit_to configuration option
4130
in the submit branch.
4131
4132
Two formats are currently supported: "4" uses revision bundle format 4 and
4133
merge directive format 2. It is significantly faster and smaller than
4134
older formats. It is compatible with Bazaar 0.19 and later. It is the
4135
default. "0.9" uses revision bundle format 0.9 and merge directive
4136
format 1. It is compatible with Bazaar 0.12 - 0.18.
4137
4138
Merge directives are applied using the merge command or the pull command.
4139
"""
4140
4141
encoding_type = 'exact'
4142
4143
_see_also = ['merge', 'pull']
4144
4145
takes_args = ['submit_branch?', 'public_branch?']
4146
4147
takes_options = [
4148
Option('no-bundle',
4149
help='Do not include a bundle in the merge directive.'),
4150
Option('no-patch', help='Do not include a preview patch in the merge'
4151
' directive.'),
4152
Option('remember',
4153
help='Remember submit and public branch.'),
4154
Option('from',
4155
help='Branch to generate the submission from, '
4156
'rather than the one containing the working directory.',
4157
short_name='f',
4158
type=unicode),
4159
Option('output', short_name='o',
4160
help='Write merge directive to this file; '
4161
'use - for stdout.',
4162
type=unicode),
4163
Option('mail-to', help='Mail the request to this address.',
4164
type=unicode),
4165
'revision',
4166
'message',
4167
RegistryOption.from_kwargs('format',
4168
'Use the specified output format.',
4169
**{'4': 'Bundle format 4, Merge Directive 2 (default)',
4170
'0.9': 'Bundle format 0.9, Merge Directive 1',})
4171
]
4172
4173
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
4174
no_patch=False, revision=None, remember=False, output=None,
4175
format='4', mail_to=None, message=None, **kwargs):
4176
return self._run(submit_branch, revision, public_branch, remember,
4177
format, no_bundle, no_patch, output,
4178
kwargs.get('from', '.'), mail_to, message)
4179
4180
def _run(self, submit_branch, revision, public_branch, remember, format,
4181
no_bundle, no_patch, output, from_, mail_to, message):
4182
from bzrlib.revision import NULL_REVISION
4183
branch = Branch.open_containing(from_)[0]
4184
if output is None:
4185
outfile = StringIO()
4186
elif output == '-':
4187
outfile = self.outf
4188
else:
4189
outfile = open(output, 'wb')
4190
# we may need to write data into branch's repository to calculate
4191
# the data to send.
4192
branch.lock_write()
4193
try:
4194
if output is None:
4195
config = branch.get_config()
4196
if mail_to is None:
4197
mail_to = config.get_user_option('submit_to')
4198
mail_client = config.get_mail_client()
4199
if remember and submit_branch is None:
4200
raise errors.BzrCommandError(
4201
'--remember requires a branch to be specified.')
4202
stored_submit_branch = branch.get_submit_branch()
4203
remembered_submit_branch = None
4204
if submit_branch is None:
4205
submit_branch = stored_submit_branch
4206
remembered_submit_branch = "submit"
4207
else:
4208
if stored_submit_branch is None or remember:
4209
branch.set_submit_branch(submit_branch)
4210
if submit_branch is None:
4211
submit_branch = branch.get_parent()
4212
remembered_submit_branch = "parent"
4213
if submit_branch is None:
4214
raise errors.BzrCommandError('No submit branch known or'
4215
' specified')
4216
if remembered_submit_branch is not None:
4217
note('Using saved %s location "%s" to determine what '
4218
'changes to submit.', remembered_submit_branch,
4219
submit_branch)
4220
4221
if mail_to is None:
4222
submit_config = Branch.open(submit_branch).get_config()
4223
mail_to = submit_config.get_user_option("child_submit_to")
4224
4225
stored_public_branch = branch.get_public_branch()
4226
if public_branch is None:
4227
public_branch = stored_public_branch
4228
elif stored_public_branch is None or remember:
4229
branch.set_public_branch(public_branch)
4230
if no_bundle and public_branch is None:
4231
raise errors.BzrCommandError('No public branch specified or'
4232
' known')
4233
base_revision_id = None
4234
revision_id = None
4235
if revision is not None:
4236
if len(revision) > 2:
4237
raise errors.BzrCommandError('bzr send takes '
4238
'at most two one revision identifiers')
4239
revision_id = revision[-1].as_revision_id(branch)
4240
if len(revision) == 2:
4241
base_revision_id = revision[0].as_revision_id(branch)
4242
if revision_id is None:
4243
revision_id = branch.last_revision()
4244
if revision_id == NULL_REVISION:
4245
raise errors.BzrCommandError('No revisions to submit.')
4246
if format == '4':
4247
directive = merge_directive.MergeDirective2.from_objects(
4248
branch.repository, revision_id, time.time(),
4249
osutils.local_time_offset(), submit_branch,
4250
public_branch=public_branch, include_patch=not no_patch,
4251
include_bundle=not no_bundle, message=message,
4252
base_revision_id=base_revision_id)
4253
elif format == '0.9':
4254
if not no_bundle:
4255
if not no_patch:
4256
patch_type = 'bundle'
4257
else:
4258
raise errors.BzrCommandError('Format 0.9 does not'
4259
' permit bundle with no patch')
4260
else:
4261
if not no_patch:
4262
patch_type = 'diff'
4263
else:
4264
patch_type = None
4265
directive = merge_directive.MergeDirective.from_objects(
4266
branch.repository, revision_id, time.time(),
4267
osutils.local_time_offset(), submit_branch,
4268
public_branch=public_branch, patch_type=patch_type,
4269
message=message)
4270
4271
outfile.writelines(directive.to_lines())
4272
if output is None:
4273
subject = '[MERGE] '
4274
if message is not None:
4275
subject += message
4276
else:
4277
revision = branch.repository.get_revision(revision_id)
4278
subject += revision.get_summary()
4279
basename = directive.get_disk_name(branch)
4280
mail_client.compose_merge_request(mail_to, subject,
4281
outfile.getvalue(), basename)
4282
finally:
4283
if output != '-':
4284
outfile.close()
4285
branch.unlock()
4286
4287
4288
class cmd_bundle_revisions(cmd_send):
4289
4290
"""Create a merge-directive for submiting changes.
4291
4292
A merge directive provides many things needed for requesting merges:
4293
4294
* A machine-readable description of the merge to perform
4295
4296
* An optional patch that is a preview of the changes requested
4297
4298
* An optional bundle of revision data, so that the changes can be applied
4299
directly from the merge directive, without retrieving data from a
4300
branch.
4301
4302
If --no-bundle is specified, then public_branch is needed (and must be
4303
up-to-date), so that the receiver can perform the merge using the
4304
public_branch. The public_branch is always included if known, so that
4305
people can check it later.
4306
4307
The submit branch defaults to the parent, but can be overridden. Both
4308
submit branch and public branch will be remembered if supplied.
4309
4310
If a public_branch is known for the submit_branch, that public submit
4311
branch is used in the merge instructions. This means that a local mirror
4312
can be used as your actual submit branch, once you have set public_branch
4313
for that mirror.
4314
4315
Two formats are currently supported: "4" uses revision bundle format 4 and
4316
merge directive format 2. It is significantly faster and smaller than
4317
older formats. It is compatible with Bazaar 0.19 and later. It is the
4318
default. "0.9" uses revision bundle format 0.9 and merge directive
4319
format 1. It is compatible with Bazaar 0.12 - 0.18.
4320
"""
4321
4322
takes_options = [
4323
Option('no-bundle',
4324
help='Do not include a bundle in the merge directive.'),
4325
Option('no-patch', help='Do not include a preview patch in the merge'
4326
' directive.'),
4327
Option('remember',
4328
help='Remember submit and public branch.'),
4329
Option('from',
4330
help='Branch to generate the submission from, '
4331
'rather than the one containing the working directory.',
4332
short_name='f',
4333
type=unicode),
4334
Option('output', short_name='o', help='Write directive to this file.',
4335
type=unicode),
4336
'revision',
4337
RegistryOption.from_kwargs('format',
4338
'Use the specified output format.',
4339
**{'4': 'Bundle format 4, Merge Directive 2 (default)',
4340
'0.9': 'Bundle format 0.9, Merge Directive 1',})
4341
]
4342
aliases = ['bundle']
4343
4344
_see_also = ['send', 'merge']
4345
4346
hidden = True
4347
4348
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
4349
no_patch=False, revision=None, remember=False, output=None,
4350
format='4', **kwargs):
4351
if output is None:
4352
output = '-'
4353
return self._run(submit_branch, revision, public_branch, remember,
4354
format, no_bundle, no_patch, output,
4355
kwargs.get('from', '.'), None, None)
4356
4357
4358
class cmd_tag(Command):
4359
"""Create, remove or modify a tag naming a revision.
4360
4361
Tags give human-meaningful names to revisions. Commands that take a -r
4362
(--revision) option can be given -rtag:X, where X is any previously
4363
created tag.
4364
4365
Tags are stored in the branch. Tags are copied from one branch to another
4366
along when you branch, push, pull or merge.
4367
4368
It is an error to give a tag name that already exists unless you pass
4369
--force, in which case the tag is moved to point to the new revision.
4370
4371
To rename a tag (change the name but keep it on the same revsion), run ``bzr
4372
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
4373
"""
4374
4375
_see_also = ['commit', 'tags']
4376
takes_args = ['tag_name']
4377
takes_options = [
4378
Option('delete',
4379
help='Delete this tag rather than placing it.',
4380
),
4381
Option('directory',
4382
help='Branch in which to place the tag.',
4383
short_name='d',
4384
type=unicode,
4385
),
4386
Option('force',
4387
help='Replace existing tags.',
4388
),
4389
'revision',
4390
]
4391
4392
def run(self, tag_name,
4393
delete=None,
4394
directory='.',
4395
force=None,
4396
revision=None,
4397
):
4398
branch, relpath = Branch.open_containing(directory)
4399
branch.lock_write()
4400
try:
4401
if delete:
4402
branch.tags.delete_tag(tag_name)
4403
self.outf.write('Deleted tag %s.\n' % tag_name)
4404
else:
4405
if revision:
4406
if len(revision) != 1:
4407
raise errors.BzrCommandError(
4408
"Tags can only be placed on a single revision, "
4409
"not on a range")
4410
revision_id = revision[0].as_revision_id(branch)
4411
else:
4412
revision_id = branch.last_revision()
4413
if (not force) and branch.tags.has_tag(tag_name):
4414
raise errors.TagAlreadyExists(tag_name)
4415
branch.tags.set_tag(tag_name, revision_id)
4416
self.outf.write('Created tag %s.\n' % tag_name)
4417
finally:
4418
branch.unlock()
4419
4420
4421
class cmd_tags(Command):
4422
"""List tags.
4423
4424
This command shows a table of tag names and the revisions they reference.
4425
"""
4426
4427
_see_also = ['tag']
4428
takes_options = [
4429
Option('directory',
4430
help='Branch whose tags should be displayed.',
4431
short_name='d',
4432
type=unicode,
4433
),
4434
RegistryOption.from_kwargs('sort',
4435
'Sort tags by different criteria.', title='Sorting',
4436
alpha='Sort tags lexicographically (default).',
4437
time='Sort tags chronologically.',
4438
),
4439
'show-ids',
4440
]
4441
4442
@display_command
4443
def run(self,
4444
directory='.',
4445
sort='alpha',
4446
show_ids=False,
4447
):
4448
branch, relpath = Branch.open_containing(directory)
4449
tags = branch.tags.get_tag_dict().items()
4450
if not tags:
4451
return
4452
if sort == 'alpha':
4453
tags.sort()
4454
elif sort == 'time':
4455
timestamps = {}
4456
for tag, revid in tags:
4457
try:
4458
revobj = branch.repository.get_revision(revid)
4459
except errors.NoSuchRevision:
4460
timestamp = sys.maxint # place them at the end
4461
else:
4462
timestamp = revobj.timestamp
4463
timestamps[revid] = timestamp
4464
tags.sort(key=lambda x: timestamps[x[1]])
4465
if not show_ids:
4466
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
4467
revno_map = branch.get_revision_id_to_revno_map()
4468
tags = [ (tag, '.'.join(map(str, revno_map.get(revid, ('?',)))))
4469
for tag, revid in tags ]
4470
for tag, revspec in tags:
4471
self.outf.write('%-20s %s\n' % (tag, revspec))
4472
4473
4474
class cmd_reconfigure(Command):
4475
"""Reconfigure the type of a bzr directory.
4476
4477
A target configuration must be specified.
4478
4479
For checkouts, the bind-to location will be auto-detected if not specified.
4480
The order of preference is
4481
1. For a lightweight checkout, the current bound location.
4482
2. For branches that used to be checkouts, the previously-bound location.
4483
3. The push location.
4484
4. The parent location.
4485
If none of these is available, --bind-to must be specified.
4486
"""
4487
4488
_see_also = ['branches', 'checkouts', 'standalone-trees', 'working-trees']
4489
takes_args = ['location?']
4490
takes_options = [RegistryOption.from_kwargs('target_type',
4491
title='Target type',
4492
help='The type to reconfigure the directory to.',
4493
value_switches=True, enum_switch=False,
4494
branch='Reconfigure to be an unbound branch '
4495
'with no working tree.',
4496
tree='Reconfigure to be an unbound branch '
4497
'with a working tree.',
4498
checkout='Reconfigure to be a bound branch '
4499
'with a working tree.',
4500
lightweight_checkout='Reconfigure to be a lightweight'
4501
' checkout (with no local history).',
4502
standalone='Reconfigure to be a standalone branch '
4503
'(i.e. stop using shared repository).',
4504
use_shared='Reconfigure to use a shared repository.'),
4505
Option('bind-to', help='Branch to bind checkout to.',
4506
type=str),
4507
Option('force',
4508
help='Perform reconfiguration even if local changes'
4509
' will be lost.')
4510
]
4511
4512
def run(self, location=None, target_type=None, bind_to=None, force=False):
4513
directory = bzrdir.BzrDir.open(location)
4514
if target_type is None:
4515
raise errors.BzrCommandError('No target configuration specified')
4516
elif target_type == 'branch':
4517
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
4518
elif target_type == 'tree':
4519
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
4520
elif target_type == 'checkout':
4521
reconfiguration = reconfigure.Reconfigure.to_checkout(directory,
4522
bind_to)
4523
elif target_type == 'lightweight-checkout':
4524
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
4525
directory, bind_to)
4526
elif target_type == 'use-shared':
4527
reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
4528
elif target_type == 'standalone':
4529
reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
4530
reconfiguration.apply(force)
4531
4532
4533
class cmd_switch(Command):
4534
"""Set the branch of a checkout and update.
4535
4536
For lightweight checkouts, this changes the branch being referenced.
4537
For heavyweight checkouts, this checks that there are no local commits
4538
versus the current bound branch, then it makes the local branch a mirror
4539
of the new location and binds to it.
4540
4541
In both cases, the working tree is updated and uncommitted changes
4542
are merged. The user can commit or revert these as they desire.
4543
4544
Pending merges need to be committed or reverted before using switch.
4545
4546
The path to the branch to switch to can be specified relative to the parent
4547
directory of the current branch. For example, if you are currently in a
4548
checkout of /path/to/branch, specifying 'newbranch' will find a branch at
4549
/path/to/newbranch.
4550
"""
4551
4552
takes_args = ['to_location']
4553
takes_options = [Option('force',
4554
help='Switch even if local commits will be lost.')
4555
]
4556
4557
def run(self, to_location, force=False):
4558
from bzrlib import switch
4559
tree_location = '.'
4560
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
4561
try:
4562
to_branch = Branch.open(to_location)
4563
except errors.NotBranchError:
4564
to_branch = Branch.open(
4565
control_dir.open_branch().base + '../' + to_location)
4566
switch.switch(control_dir, to_branch, force)
4567
note('Switched to branch: %s',
4568
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
4569
4570
4571
class cmd_hooks(Command):
4572
"""Show a branch's currently registered hooks.
4573
"""
4574
4575
hidden = True
4576
takes_args = ['path?']
4577
4578
def run(self, path=None):
4579
if path is None:
4580
path = '.'
4581
branch_hooks = Branch.open(path).hooks
4582
for hook_type in branch_hooks:
4583
hooks = branch_hooks[hook_type]
4584
self.outf.write("%s:\n" % (hook_type,))
4585
if hooks:
4586
for hook in hooks:
4587
self.outf.write(" %s\n" %
4588
(branch_hooks.get_hook_name(hook),))
4589
else:
4590
self.outf.write(" <no hooks installed>\n")
4591
4592
4593
def _create_prefix(cur_transport):
4594
needed = [cur_transport]
4595
# Recurse upwards until we can create a directory successfully
4596
while True:
4597
new_transport = cur_transport.clone('..')
4598
if new_transport.base == cur_transport.base:
4599
raise errors.BzrCommandError(
4600
"Failed to create path prefix for %s."
4601
% cur_transport.base)
4602
try:
4603
new_transport.mkdir('.')
4604
except errors.NoSuchFile:
4605
needed.append(new_transport)
4606
cur_transport = new_transport
4607
else:
4608
break
4609
# Now we only need to create child directories
4610
while needed:
4611
cur_transport = needed.pop()
4612
cur_transport.ensure_base()
2544
2545
# command-line interpretation helper for merge-related commands
2546
def merge(other_revision, base_revision,
2547
check_clean=True, ignore_zero=False,
2548
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2549
file_list=None, show_base=False, reprocess=False,
2550
pb=DummyProgress()):
2551
"""Merge changes into a tree.
2552
2553
base_revision
2554
list(path, revno) Base for three-way merge.
2555
If [None, None] then a base will be automatically determined.
2556
other_revision
2557
list(path, revno) Other revision for three-way merge.
2558
this_dir
2559
Directory to merge changes into; '.' by default.
2560
check_clean
2561
If true, this_dir must have no uncommitted changes before the
2562
merge begins.
2563
ignore_zero - If true, suppress the "zero conflicts" message when
2564
there are no conflicts; should be set when doing something we expect
2565
to complete perfectly.
2566
file_list - If supplied, merge only changes to selected files.
2567
2568
All available ancestors of other_revision and base_revision are
2569
automatically pulled into the branch.
2570
2571
The revno may be -1 to indicate the last revision on the branch, which is
2572
the typical case.
2573
2574
This function is intended for use from the command line; programmatic
2575
clients might prefer to call merge.merge_inner(), which has less magic
2576
behavior.
2577
"""
2578
from bzrlib.merge import Merger
2579
if this_dir is None:
2580
this_dir = u'.'
2581
this_tree = WorkingTree.open_containing(this_dir)[0]
2582
if show_base and not merge_type is Merge3Merger:
2583
raise BzrCommandError("Show-base is not supported for this merge"
2584
" type. %s" % merge_type)
2585
if reprocess and not merge_type.supports_reprocess:
2586
raise BzrCommandError("Conflict reduction is not supported for merge"
2587
" type %s." % merge_type)
2588
if reprocess and show_base:
2589
raise BzrCommandError("Cannot do conflict reduction and show base.")
2590
try:
2591
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2592
merger.pp = ProgressPhase("Merge phase", 5, pb)
2593
merger.pp.next_phase()
2594
merger.check_basis(check_clean)
2595
merger.set_other(other_revision)
2596
merger.pp.next_phase()
2597
merger.set_base(base_revision)
2598
if merger.base_rev_id == merger.other_rev_id:
2599
note('Nothing to do.')
2600
return 0
2601
merger.backup_files = backup_files
2602
merger.merge_type = merge_type
2603
merger.set_interesting_files(file_list)
2604
merger.show_base = show_base
2605
merger.reprocess = reprocess
2606
conflicts = merger.do_merge()
2607
if file_list is None:
2608
merger.set_pending()
2609
finally:
2610
pb.clear()
2611
return conflicts
4613
2612
4614
2613
4615
2614
# these get imported and then picked up by the scan for cmd_*
4617
2616
# we do need to load at least some information about them to know of
4618
2617
# aliases. ideally we would avoid loading the implementation until the
4619
2618
# details were needed.
4620
from bzrlib.cmd_version_info import cmd_version_info
4621
2619
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
4622
from bzrlib.bundle.commands import (
4623
cmd_bundle_info,
4624
)
4625
2620
from bzrlib.sign_my_commits import cmd_sign_my_commits
4626
from bzrlib.weave_commands import cmd_versionedfile_list, \
2621
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
4627
2622
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1