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