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