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