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