To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1996.3.5
- compare with another revision
- download diff
- download tarball
- view history from revision 1996.3.5
- Committer: John Arbash Meinel
- Date: 2006-09-12 20:46:42 UTC
- mto: This revision was merged to the branch mainline in revision 2071.
- Revision ID: john@arbash-meinel.com-20060912204642-91599869cc863f07
Cleanup, deprecated, and get the tests passing again.
bzrlib.builtins.merge is heavily used by the test suite, though it is
really the wrong place for a function like that.
lazy imports work badly with doctests, but so far none of the doc tested
modules had anything worth testing in that fashion.
bzrlib.builtins.merge is heavily used by the test suite, though it is
really the wrong place for a function like that.
lazy imports work badly with doctests, but so far none of the doc tested
modules had anything worth testing in that fashion.
- files added:
- .bzrignore
- bzrlib
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/plugins/launchpad
- bzrlib/store
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/intertree_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- doc
- tools
- tools/doc_generate
- tools/win32
- files removed:
- .bzrignore
- notes
- tests
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
2
#
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
#
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
12
#
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
"""builtin bzr commands"""
18
19
import os
20
21
from bzrlib.lazy_import import lazy_import
22
lazy_import(globals(), """
23
import codecs
24
import errno
25
import sys
26
27
import bzrlib
28
from bzrlib import (
29
branch,
30
bundle,
31
bzrdir,
32
config,
33
errors,
34
ignores,
35
log,
36
merge as _mod_merge,
37
osutils,
38
repository,
39
transport,
40
ui,
41
urlutils,
42
)
43
from bzrlib.branch import Branch
44
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
45
from bzrlib.conflicts import ConflictList
46
from bzrlib.revision import common_ancestor
47
from bzrlib.revisionspec import RevisionSpec
48
from bzrlib.workingtree import WorkingTree
49
""")
50
51
from bzrlib.commands import Command, display_command
52
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
53
NotBranchError, DivergedBranches, NotConflicted,
54
NoSuchFile, NoWorkingTree, FileInWrongBranch,
55
NotVersionedError, NotABundle)
56
from bzrlib.option import Option
57
from bzrlib.progress import DummyProgress, ProgressPhase
58
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
59
from bzrlib.transport.local import LocalTransport
60
61
62
def tree_files(file_list, default_branch=u'.'):
63
try:
64
return internal_tree_files(file_list, default_branch)
65
except FileInWrongBranch, e:
66
raise BzrCommandError("%s is not in the same branch as %s" %
67
(e.path, file_list[0]))
68
69
70
# XXX: Bad function name; should possibly also be a class method of
71
# WorkingTree rather than a function.
72
def internal_tree_files(file_list, default_branch=u'.'):
73
"""Convert command-line paths to a WorkingTree and relative paths.
74
75
This is typically used for command-line processors that take one or
76
more filenames, and infer the workingtree that contains them.
77
78
The filenames given are not required to exist.
79
80
:param file_list: Filenames to convert.
81
82
:param default_branch: Fallback tree path to use if file_list is empty or None.
83
84
:return: workingtree, [relative_paths]
85
"""
86
if file_list is None or len(file_list) == 0:
87
return WorkingTree.open_containing(default_branch)[0], file_list
88
tree = WorkingTree.open_containing(file_list[0])[0]
89
new_list = []
90
for filename in file_list:
91
try:
92
new_list.append(tree.relpath(filename))
93
except errors.PathNotChild:
94
raise FileInWrongBranch(tree.branch, filename)
95
return tree, new_list
96
97
98
def get_format_type(typestring):
99
"""Parse and return a format specifier."""
100
if typestring == "weave":
101
return bzrdir.BzrDirFormat6()
102
if typestring == "default":
103
return bzrdir.BzrDirMetaFormat1()
104
if typestring == "metaweave":
105
format = bzrdir.BzrDirMetaFormat1()
106
format.repository_format = repository.RepositoryFormat7()
107
return format
108
if typestring == "knit":
109
format = bzrdir.BzrDirMetaFormat1()
110
format.repository_format = repository.RepositoryFormatKnit1()
111
return format
112
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
113
"metaweave and weave" % typestring
114
raise BzrCommandError(msg)
115
116
117
# TODO: Make sure no commands unconditionally use the working directory as a
118
# branch. If a filename argument is used, the first of them should be used to
119
# specify the branch. (Perhaps this can be factored out into some kind of
120
# Argument class, representing a file in a branch, where the first occurrence
121
# opens the branch?)
122
123
class cmd_status(Command):
124
"""Display status summary.
125
126
This reports on versioned and unknown files, reporting them
127
grouped by state. Possible states are:
128
129
added
130
Versioned in the working copy but not in the previous revision.
131
132
removed
133
Versioned in the previous revision but removed or deleted
134
in the working copy.
135
136
renamed
137
Path of this file changed from the previous revision;
138
the text may also have changed. This includes files whose
139
parent directory was renamed.
140
141
modified
142
Text has changed since the previous revision.
143
144
unknown
145
Not versioned and not matching an ignore pattern.
146
147
To see ignored files use 'bzr ignored'. For details in the
148
changes to file texts, use 'bzr diff'.
149
150
If no arguments are specified, the status of the entire working
151
directory is shown. Otherwise, only the status of the specified
152
files or directories is reported. If a directory is given, status
153
is reported for everything inside that directory.
154
155
If a revision argument is given, the status is calculated against
156
that revision, or between two revisions if two are provided.
157
"""
158
159
# TODO: --no-recurse, --recurse options
160
161
takes_args = ['file*']
162
takes_options = ['show-ids', 'revision']
163
aliases = ['st', 'stat']
164
165
encoding_type = 'replace'
166
167
@display_command
168
def run(self, show_ids=False, file_list=None, revision=None):
169
from bzrlib.status import show_tree_status
170
171
tree, file_list = tree_files(file_list)
172
173
show_tree_status(tree, show_ids=show_ids,
174
specific_files=file_list, revision=revision,
175
to_file=self.outf)
176
177
178
class cmd_cat_revision(Command):
179
"""Write out metadata for a revision.
180
181
The revision to print can either be specified by a specific
182
revision identifier, or you can use --revision.
183
"""
184
185
hidden = True
186
takes_args = ['revision_id?']
187
takes_options = ['revision']
188
# cat-revision is more for frontends so should be exact
189
encoding = 'strict'
190
191
@display_command
192
def run(self, revision_id=None, revision=None):
193
194
if revision_id is not None and revision is not None:
195
raise BzrCommandError('You can only supply one of revision_id or --revision')
196
if revision_id is None and revision is None:
197
raise BzrCommandError('You must supply either --revision or a revision_id')
198
b = WorkingTree.open_containing(u'.')[0].branch
199
200
# TODO: jam 20060112 should cat-revision always output utf-8?
201
if revision_id is not None:
202
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
203
elif revision is not None:
204
for rev in revision:
205
if rev is None:
206
raise BzrCommandError('You cannot specify a NULL revision.')
207
revno, rev_id = rev.in_history(b)
208
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
209
210
211
class cmd_revno(Command):
212
"""Show current revision number.
213
214
This is equal to the number of revisions on this branch.
215
"""
216
217
takes_args = ['location?']
218
219
@display_command
220
def run(self, location=u'.'):
221
self.outf.write(str(Branch.open_containing(location)[0].revno()))
222
self.outf.write('\n')
223
224
225
class cmd_revision_info(Command):
226
"""Show revision number and revision id for a given revision identifier.
227
"""
228
hidden = True
229
takes_args = ['revision_info*']
230
takes_options = ['revision']
231
232
@display_command
233
def run(self, revision=None, revision_info_list=[]):
234
235
revs = []
236
if revision is not None:
237
revs.extend(revision)
238
if revision_info_list is not None:
239
for rev in revision_info_list:
240
revs.append(RevisionSpec.from_string(rev))
241
if len(revs) == 0:
242
raise BzrCommandError('You must supply a revision identifier')
243
244
b = WorkingTree.open_containing(u'.')[0].branch
245
246
for rev in revs:
247
revinfo = rev.in_history(b)
248
if revinfo.revno is None:
249
print ' %s' % revinfo.rev_id
250
else:
251
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
252
253
254
class cmd_add(Command):
255
"""Add specified files or directories.
256
257
In non-recursive mode, all the named items are added, regardless
258
of whether they were previously ignored. A warning is given if
259
any of the named files are already versioned.
260
261
In recursive mode (the default), files are treated the same way
262
but the behaviour for directories is different. Directories that
263
are already versioned do not give a warning. All directories,
264
whether already versioned or not, are searched for files or
265
subdirectories that are neither versioned or ignored, and these
266
are added. This search proceeds recursively into versioned
267
directories. If no names are given '.' is assumed.
268
269
Therefore simply saying 'bzr add' will version all files that
270
are currently unknown.
271
272
Adding a file whose parent directory is not versioned will
273
implicitly add the parent, and so on up to the root. This means
274
you should never need to explicitly add a directory, they'll just
275
get added when you add a file in the directory.
276
277
--dry-run will show which files would be added, but not actually
278
add them.
279
280
--file-ids-from will try to use the file ids from the supplied path.
281
It looks up ids trying to find a matching parent directory with the
282
same filename, and then by pure path.
283
"""
284
takes_args = ['file*']
285
takes_options = ['no-recurse', 'dry-run', 'verbose',
286
Option('file-ids-from', type=unicode,
287
help='Lookup file ids from here')]
288
encoding_type = 'replace'
289
290
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
291
file_ids_from=None):
292
import bzrlib.add
293
294
if file_ids_from is not None:
295
try:
296
base_tree, base_path = WorkingTree.open_containing(
297
file_ids_from)
298
except errors.NoWorkingTree:
299
base_branch, base_path = Branch.open_containing(
300
file_ids_from)
301
base_tree = base_branch.basis_tree()
302
303
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
304
to_file=self.outf, should_print=(not is_quiet()))
305
else:
306
action = bzrlib.add.AddAction(to_file=self.outf,
307
should_print=(not is_quiet()))
308
309
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
310
action=action, save=not dry_run)
311
if len(ignored) > 0:
312
if verbose:
313
for glob in sorted(ignored.keys()):
314
for path in ignored[glob]:
315
self.outf.write("ignored %s matching \"%s\"\n"
316
% (path, glob))
317
else:
318
match_len = 0
319
for glob, paths in ignored.items():
320
match_len += len(paths)
321
self.outf.write("ignored %d file(s).\n" % match_len)
322
self.outf.write("If you wish to add some of these files,"
323
" please add them by name.\n")
324
325
326
class cmd_mkdir(Command):
327
"""Create a new versioned directory.
328
329
This is equivalent to creating the directory and then adding it.
330
"""
331
332
takes_args = ['dir+']
333
encoding_type = 'replace'
334
335
def run(self, dir_list):
336
for d in dir_list:
337
os.mkdir(d)
338
wt, dd = WorkingTree.open_containing(d)
339
wt.add([dd])
340
self.outf.write('added %s\n' % d)
341
342
343
class cmd_relpath(Command):
344
"""Show path of a file relative to root"""
345
346
takes_args = ['filename']
347
hidden = True
348
349
@display_command
350
def run(self, filename):
351
# TODO: jam 20050106 Can relpath return a munged path if
352
# sys.stdout encoding cannot represent it?
353
tree, relpath = WorkingTree.open_containing(filename)
354
self.outf.write(relpath)
355
self.outf.write('\n')
356
357
358
class cmd_inventory(Command):
359
"""Show inventory of the current working copy or a revision.
360
361
It is possible to limit the output to a particular entry
362
type using the --kind option. For example; --kind file.
363
"""
364
365
takes_options = ['revision', 'show-ids', 'kind']
366
367
@display_command
368
def run(self, revision=None, show_ids=False, kind=None):
369
if kind and kind not in ['file', 'directory', 'symlink']:
370
raise BzrCommandError('invalid kind specified')
371
tree = WorkingTree.open_containing(u'.')[0]
372
if revision is None:
373
inv = tree.read_working_inventory()
374
else:
375
if len(revision) > 1:
376
raise BzrCommandError('bzr inventory --revision takes'
377
' exactly one revision identifier')
378
inv = tree.branch.repository.get_revision_inventory(
379
revision[0].in_history(tree.branch).rev_id)
380
381
for path, entry in inv.entries():
382
if kind and kind != entry.kind:
383
continue
384
if show_ids:
385
self.outf.write('%-50s %s\n' % (path, entry.file_id))
386
else:
387
self.outf.write(path)
388
self.outf.write('\n')
389
390
391
class cmd_mv(Command):
392
"""Move or rename a file.
393
394
usage:
395
bzr mv OLDNAME NEWNAME
396
bzr mv SOURCE... DESTINATION
397
398
If the last argument is a versioned directory, all the other names
399
are moved into it. Otherwise, there must be exactly two arguments
400
and the file is changed to a new name, which must not already exist.
401
402
Files cannot be moved between branches.
403
"""
404
405
takes_args = ['names*']
406
aliases = ['move', 'rename']
407
encoding_type = 'replace'
408
409
def run(self, names_list):
410
if names_list is None:
411
names_list = []
412
413
if len(names_list) < 2:
414
raise BzrCommandError("missing file argument")
415
tree, rel_names = tree_files(names_list)
416
417
if os.path.isdir(names_list[-1]):
418
# move into existing directory
419
for pair in tree.move(rel_names[:-1], rel_names[-1]):
420
self.outf.write("%s => %s\n" % pair)
421
else:
422
if len(names_list) != 2:
423
raise BzrCommandError('to mv multiple files the destination '
424
'must be a versioned directory')
425
tree.rename_one(rel_names[0], rel_names[1])
426
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
427
428
429
class cmd_pull(Command):
430
"""Turn this branch into a mirror of another branch.
431
432
This command only works on branches that have not diverged. Branches are
433
considered diverged if the destination branch's most recent commit is one
434
that has not been merged (directly or indirectly) into the parent.
435
436
If branches have diverged, you can use 'bzr merge' to integrate the changes
437
from one into the other. Once one branch has merged, the other should
438
be able to pull it again.
439
440
If you want to forget your local changes and just update your branch to
441
match the remote one, use pull --overwrite.
442
443
If there is no default location set, the first pull will set it. After
444
that, you can omit the location to use the default. To change the
445
default, use --remember. The value will only be saved if the remote
446
location can be accessed.
447
"""
448
449
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
450
takes_args = ['location?']
451
encoding_type = 'replace'
452
453
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
454
# FIXME: too much stuff is in the command class
455
try:
456
tree_to = WorkingTree.open_containing(u'.')[0]
457
branch_to = tree_to.branch
458
except NoWorkingTree:
459
tree_to = None
460
branch_to = Branch.open_containing(u'.')[0]
461
462
reader = None
463
if location is not None:
464
try:
465
reader = bundle.read_bundle_from_url(location)
466
except NotABundle:
467
pass # Continue on considering this url a Branch
468
469
stored_loc = branch_to.get_parent()
470
if location is None:
471
if stored_loc is None:
472
raise BzrCommandError("No pull location known or specified.")
473
else:
474
display_url = urlutils.unescape_for_display(stored_loc,
475
self.outf.encoding)
476
self.outf.write("Using saved location: %s\n" % display_url)
477
location = stored_loc
478
479
480
if reader is not None:
481
install_bundle(branch_to.repository, reader)
482
branch_from = branch_to
483
else:
484
branch_from = Branch.open(location)
485
486
if branch_to.get_parent() is None or remember:
487
branch_to.set_parent(branch_from.base)
488
489
rev_id = None
490
if revision is None:
491
if reader is not None:
492
rev_id = reader.target
493
elif len(revision) == 1:
494
rev_id = revision[0].in_history(branch_from).rev_id
495
else:
496
raise BzrCommandError('bzr pull --revision takes one value.')
497
498
old_rh = branch_to.revision_history()
499
if tree_to is not None:
500
count = tree_to.pull(branch_from, overwrite, rev_id)
501
else:
502
count = branch_to.pull(branch_from, overwrite, rev_id)
503
note('%d revision(s) pulled.' % (count,))
504
505
if verbose:
506
new_rh = branch_to.revision_history()
507
if old_rh != new_rh:
508
# Something changed
509
from bzrlib.log import show_changed_revisions
510
show_changed_revisions(branch_to, old_rh, new_rh,
511
to_file=self.outf)
512
513
514
class cmd_push(Command):
515
"""Update a mirror of this branch.
516
517
The target branch will not have its working tree populated because this
518
is both expensive, and is not supported on remote file systems.
519
520
Some smart servers or protocols *may* put the working tree in place in
521
the future.
522
523
This command only works on branches that have not diverged. Branches are
524
considered diverged if the destination branch's most recent commit is one
525
that has not been merged (directly or indirectly) by the source branch.
526
527
If branches have diverged, you can use 'bzr push --overwrite' to replace
528
the other branch completely, discarding its unmerged changes.
529
530
If you want to ensure you have the different changes in the other branch,
531
do a merge (see bzr help merge) from the other branch, and commit that.
532
After that you will be able to do a push without '--overwrite'.
533
534
If there is no default push location set, the first push will set it.
535
After that, you can omit the location to use the default. To change the
536
default, use --remember. The value will only be saved if the remote
537
location can be accessed.
538
"""
539
540
takes_options = ['remember', 'overwrite', 'verbose',
541
Option('create-prefix',
542
help='Create the path leading up to the branch '
543
'if it does not already exist')]
544
takes_args = ['location?']
545
encoding_type = 'replace'
546
547
def run(self, location=None, remember=False, overwrite=False,
548
create_prefix=False, verbose=False):
549
# FIXME: Way too big! Put this into a function called from the
550
# command.
551
552
br_from = Branch.open_containing('.')[0]
553
stored_loc = br_from.get_push_location()
554
if location is None:
555
if stored_loc is None:
556
raise BzrCommandError("No push location known or specified.")
557
else:
558
display_url = urlutils.unescape_for_display(stored_loc,
559
self.outf.encoding)
560
self.outf.write("Using saved location: %s\n" % display_url)
561
location = stored_loc
562
563
to_transport = transport.get_transport(location)
564
location_url = to_transport.base
565
566
old_rh = []
567
try:
568
dir_to = bzrdir.BzrDir.open(location_url)
569
br_to = dir_to.open_branch()
570
except NotBranchError:
571
# create a branch.
572
to_transport = to_transport.clone('..')
573
if not create_prefix:
574
try:
575
relurl = to_transport.relpath(location_url)
576
mutter('creating directory %s => %s', location_url, relurl)
577
to_transport.mkdir(relurl)
578
except NoSuchFile:
579
raise BzrCommandError("Parent directory of %s "
580
"does not exist." % location)
581
else:
582
current = to_transport.base
583
needed = [(to_transport, to_transport.relpath(location_url))]
584
while needed:
585
try:
586
to_transport, relpath = needed[-1]
587
to_transport.mkdir(relpath)
588
needed.pop()
589
except NoSuchFile:
590
new_transport = to_transport.clone('..')
591
needed.append((new_transport,
592
new_transport.relpath(to_transport.base)))
593
if new_transport.base == to_transport.base:
594
raise BzrCommandError("Could not create "
595
"path prefix.")
596
dir_to = br_from.bzrdir.clone(location_url,
597
revision_id=br_from.last_revision())
598
br_to = dir_to.open_branch()
599
count = len(br_to.revision_history())
600
# We successfully created the target, remember it
601
if br_from.get_push_location() is None or remember:
602
br_from.set_push_location(br_to.base)
603
else:
604
# We were able to connect to the remote location, so remember it
605
# we don't need to successfully push because of possible divergence.
606
if br_from.get_push_location() is None or remember:
607
br_from.set_push_location(br_to.base)
608
old_rh = br_to.revision_history()
609
try:
610
try:
611
tree_to = dir_to.open_workingtree()
612
except errors.NotLocalUrl:
613
warning('This transport does not update the working '
614
'tree of: %s' % (br_to.base,))
615
count = br_to.pull(br_from, overwrite)
616
except NoWorkingTree:
617
count = br_to.pull(br_from, overwrite)
618
else:
619
count = tree_to.pull(br_from, overwrite)
620
except DivergedBranches:
621
raise BzrCommandError("These branches have diverged."
622
" Try a merge then push with overwrite.")
623
note('%d revision(s) pushed.' % (count,))
624
625
if verbose:
626
new_rh = br_to.revision_history()
627
if old_rh != new_rh:
628
# Something changed
629
from bzrlib.log import show_changed_revisions
630
show_changed_revisions(br_to, old_rh, new_rh,
631
to_file=self.outf)
632
633
634
class cmd_branch(Command):
635
"""Create a new copy of a branch.
636
637
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
638
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
639
640
To retrieve the branch as of a particular revision, supply the --revision
641
parameter, as in "branch foo/bar -r 5".
642
643
--basis is to speed up branching from remote branches. When specified, it
644
copies all the file-contents, inventory and revision data from the basis
645
branch before copying anything from the remote branch.
646
"""
647
takes_args = ['from_location', 'to_location?']
648
takes_options = ['revision', 'basis']
649
aliases = ['get', 'clone']
650
651
def run(self, from_location, to_location=None, revision=None, basis=None):
652
if revision is None:
653
revision = [None]
654
elif len(revision) > 1:
655
raise BzrCommandError(
656
'bzr branch --revision takes exactly 1 revision value')
657
try:
658
br_from = Branch.open(from_location)
659
except OSError, e:
660
if e.errno == errno.ENOENT:
661
raise BzrCommandError('Source location "%s" does not'
662
' exist.' % to_location)
663
else:
664
raise
665
br_from.lock_read()
666
try:
667
if basis is not None:
668
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
669
else:
670
basis_dir = None
671
if len(revision) == 1 and revision[0] is not None:
672
revision_id = revision[0].in_history(br_from)[1]
673
else:
674
# FIXME - wt.last_revision, fallback to branch, fall back to
675
# None or perhaps NULL_REVISION to mean copy nothing
676
# RBC 20060209
677
revision_id = br_from.last_revision()
678
if to_location is None:
679
to_location = os.path.basename(from_location.rstrip("/\\"))
680
name = None
681
else:
682
name = os.path.basename(to_location) + '\n'
683
684
to_transport = transport.get_transport(to_location)
685
try:
686
to_transport.mkdir('.')
687
except errors.FileExists:
688
raise BzrCommandError('Target directory "%s" already'
689
' exists.' % to_location)
690
except errors.NoSuchFile:
691
raise BzrCommandError('Parent of "%s" does not exist.' %
692
to_location)
693
try:
694
# preserve whatever source format we have.
695
dir = br_from.bzrdir.sprout(to_transport.base,
696
revision_id, basis_dir)
697
branch = dir.open_branch()
698
except errors.NoSuchRevision:
699
to_transport.delete_tree('.')
700
msg = "The branch %s has no revision %s." % (from_location, revision[0])
701
raise BzrCommandError(msg)
702
except errors.UnlistableBranch:
703
osutils.rmtree(to_location)
704
msg = "The branch %s cannot be used as a --basis" % (basis,)
705
raise BzrCommandError(msg)
706
if name:
707
branch.control_files.put_utf8('branch-name', name)
708
note('Branched %d revision(s).' % branch.revno())
709
finally:
710
br_from.unlock()
711
712
713
class cmd_checkout(Command):
714
"""Create a new checkout of an existing branch.
715
716
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
717
the branch found in '.'. This is useful if you have removed the working tree
718
or if it was never created - i.e. if you pushed the branch to its current
719
location using SFTP.
720
721
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
722
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
723
724
To retrieve the branch as of a particular revision, supply the --revision
725
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
726
out of date [so you cannot commit] but it may be useful (i.e. to examine old
727
code.)
728
729
--basis is to speed up checking out from remote branches. When specified, it
730
uses the inventory and file contents from the basis branch in preference to the
731
branch being checked out.
732
"""
733
takes_args = ['branch_location?', 'to_location?']
734
takes_options = ['revision', # , 'basis']
735
Option('lightweight',
736
help="perform a lightweight checkout. Lightweight "
737
"checkouts depend on access to the branch for "
738
"every operation. Normal checkouts can perform "
739
"common operations like diff and status without "
740
"such access, and also support local commits."
741
),
742
]
743
aliases = ['co']
744
745
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
746
lightweight=False):
747
if revision is None:
748
revision = [None]
749
elif len(revision) > 1:
750
raise BzrCommandError(
751
'bzr checkout --revision takes exactly 1 revision value')
752
if branch_location is None:
753
branch_location = osutils.getcwd()
754
to_location = branch_location
755
source = Branch.open(branch_location)
756
if len(revision) == 1 and revision[0] is not None:
757
revision_id = revision[0].in_history(source)[1]
758
else:
759
revision_id = None
760
if to_location is None:
761
to_location = os.path.basename(branch_location.rstrip("/\\"))
762
# if the source and to_location are the same,
763
# and there is no working tree,
764
# then reconstitute a branch
765
if (osutils.abspath(to_location) ==
766
osutils.abspath(branch_location)):
767
try:
768
source.bzrdir.open_workingtree()
769
except errors.NoWorkingTree:
770
source.bzrdir.create_workingtree()
771
return
772
try:
773
os.mkdir(to_location)
774
except OSError, e:
775
if e.errno == errno.EEXIST:
776
raise BzrCommandError('Target directory "%s" already'
777
' exists.' % to_location)
778
if e.errno == errno.ENOENT:
779
raise BzrCommandError('Parent of "%s" does not exist.' %
780
to_location)
781
else:
782
raise
783
old_format = bzrdir.BzrDirFormat.get_default_format()
784
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
785
try:
786
source.create_checkout(to_location, revision_id, lightweight)
787
finally:
788
bzrdir.BzrDirFormat.set_default_format(old_format)
789
790
791
class cmd_renames(Command):
792
"""Show list of renamed files.
793
"""
794
# TODO: Option to show renames between two historical versions.
795
796
# TODO: Only show renames under dir, rather than in the whole branch.
797
takes_args = ['dir?']
798
799
@display_command
800
def run(self, dir=u'.'):
801
from bzrlib.tree import find_renames
802
tree = WorkingTree.open_containing(dir)[0]
803
old_inv = tree.basis_tree().inventory
804
new_inv = tree.read_working_inventory()
805
renames = list(find_renames(old_inv, new_inv))
806
renames.sort()
807
for old_name, new_name in renames:
808
self.outf.write("%s => %s\n" % (old_name, new_name))
809
810
811
class cmd_update(Command):
812
"""Update a tree to have the latest code committed to its branch.
813
814
This will perform a merge into the working tree, and may generate
815
conflicts. If you have any local changes, you will still
816
need to commit them after the update for the update to be complete.
817
818
If you want to discard your local changes, you can just do a
819
'bzr revert' instead of 'bzr commit' after the update.
820
"""
821
takes_args = ['dir?']
822
aliases = ['up']
823
824
def run(self, dir='.'):
825
tree = WorkingTree.open_containing(dir)[0]
826
tree.lock_write()
827
try:
828
existing_pending_merges = tree.pending_merges()
829
last_rev = tree.last_revision()
830
if last_rev == tree.branch.last_revision():
831
# may be up to date, check master too.
832
master = tree.branch.get_master_branch()
833
if master is None or last_rev == master.last_revision():
834
revno = tree.branch.revision_id_to_revno(last_rev)
835
note("Tree is up to date at revision %d." % (revno,))
836
return 0
837
conflicts = tree.update()
838
revno = tree.branch.revision_id_to_revno(tree.last_revision())
839
note('Updated to revision %d.' % (revno,))
840
if tree.pending_merges() != existing_pending_merges:
841
note('Your local commits will now show as pending merges with '
842
"'bzr status', and can be committed with 'bzr commit'.")
843
if conflicts != 0:
844
return 1
845
else:
846
return 0
847
finally:
848
tree.unlock()
849
850
851
class cmd_info(Command):
852
"""Show information about a working tree, branch or repository.
853
854
This command will show all known locations and formats associated to the
855
tree, branch or repository. Statistical information is included with
856
each report.
857
858
Branches and working trees will also report any missing revisions.
859
"""
860
takes_args = ['location?']
861
takes_options = ['verbose']
862
863
@display_command
864
def run(self, location=None, verbose=False):
865
from bzrlib.info import show_bzrdir_info
866
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
867
verbose=verbose)
868
869
870
class cmd_remove(Command):
871
"""Make a file unversioned.
872
873
This makes bzr stop tracking changes to a versioned file. It does
874
not delete the working copy.
875
876
You can specify one or more files, and/or --new. If you specify --new,
877
only 'added' files will be removed. If you specify both, then new files
878
in the specified directories will be removed. If the directories are
879
also new, they will also be removed.
880
"""
881
takes_args = ['file*']
882
takes_options = ['verbose', Option('new', help='remove newly-added files')]
883
aliases = ['rm']
884
encoding_type = 'replace'
885
886
def run(self, file_list, verbose=False, new=False):
887
tree, file_list = tree_files(file_list)
888
if new is False:
889
if file_list is None:
890
raise BzrCommandError('Specify one or more files to remove, or'
891
' use --new.')
892
else:
893
added = tree.changes_from(tree.basis_tree(),
894
specific_files=file_list).added
895
file_list = sorted([f[0] for f in added], reverse=True)
896
if len(file_list) == 0:
897
raise BzrCommandError('No matching files.')
898
tree.remove(file_list, verbose=verbose, to_file=self.outf)
899
900
901
class cmd_file_id(Command):
902
"""Print file_id of a particular file or directory.
903
904
The file_id is assigned when the file is first added and remains the
905
same through all revisions where the file exists, even when it is
906
moved or renamed.
907
"""
908
909
hidden = True
910
takes_args = ['filename']
911
912
@display_command
913
def run(self, filename):
914
tree, relpath = WorkingTree.open_containing(filename)
915
i = tree.inventory.path2id(relpath)
916
if i is None:
917
raise BzrError("%r is not a versioned file" % filename)
918
else:
919
self.outf.write(i + '\n')
920
921
922
class cmd_file_path(Command):
923
"""Print path of file_ids to a file or directory.
924
925
This prints one line for each directory down to the target,
926
starting at the branch root.
927
"""
928
929
hidden = True
930
takes_args = ['filename']
931
932
@display_command
933
def run(self, filename):
934
tree, relpath = WorkingTree.open_containing(filename)
935
inv = tree.inventory
936
fid = inv.path2id(relpath)
937
if fid is None:
938
raise BzrError("%r is not a versioned file" % filename)
939
for fip in inv.get_idpath(fid):
940
self.outf.write(fip + '\n')
941
942
943
class cmd_reconcile(Command):
944
"""Reconcile bzr metadata in a branch.
945
946
This can correct data mismatches that may have been caused by
947
previous ghost operations or bzr upgrades. You should only
948
need to run this command if 'bzr check' or a bzr developer
949
advises you to run it.
950
951
If a second branch is provided, cross-branch reconciliation is
952
also attempted, which will check that data like the tree root
953
id which was not present in very early bzr versions is represented
954
correctly in both branches.
955
956
At the same time it is run it may recompress data resulting in
957
a potential saving in disk space or performance gain.
958
959
The branch *MUST* be on a listable system such as local disk or sftp.
960
"""
961
takes_args = ['branch?']
962
963
def run(self, branch="."):
964
from bzrlib.reconcile import reconcile
965
dir = bzrdir.BzrDir.open(branch)
966
reconcile(dir)
967
968
969
class cmd_revision_history(Command):
970
"""Display the list of revision ids on a branch."""
971
takes_args = ['location?']
972
973
hidden = True
974
975
@display_command
976
def run(self, location="."):
977
branch = Branch.open_containing(location)[0]
978
for revid in branch.revision_history():
979
self.outf.write(revid)
980
self.outf.write('\n')
981
982
983
class cmd_ancestry(Command):
984
"""List all revisions merged into this branch."""
985
takes_args = ['location?']
986
987
hidden = True
988
989
@display_command
990
def run(self, location="."):
991
try:
992
wt = WorkingTree.open_containing(location)[0]
993
except errors.NoWorkingTree:
994
b = Branch.open(location)
995
last_revision = b.last_revision()
996
else:
997
b = wt.branch
998
last_revision = wt.last_revision()
999
1000
revision_ids = b.repository.get_ancestry(last_revision)
1001
assert revision_ids[0] is None
1002
revision_ids.pop(0)
1003
for revision_id in revision_ids:
1004
self.outf.write(revision_id + '\n')
1005
1006
1007
class cmd_init(Command):
1008
"""Make a directory into a versioned branch.
1009
1010
Use this to create an empty branch, or before importing an
1011
existing project.
1012
1013
If there is a repository in a parent directory of the location, then
1014
the history of the branch will be stored in the repository. Otherwise
1015
init creates a standalone branch which carries its own history in
1016
.bzr.
1017
1018
If there is already a branch at the location but it has no working tree,
1019
the tree can be populated with 'bzr checkout'.
1020
1021
Recipe for importing a tree of files:
1022
cd ~/project
1023
bzr init
1024
bzr add .
1025
bzr status
1026
bzr commit -m 'imported project'
1027
"""
1028
takes_args = ['location?']
1029
takes_options = [
1030
Option('format',
1031
help='Specify a format for this branch. Current'
1032
' formats are: default, knit, metaweave and'
1033
' weave. Default is knit; metaweave and'
1034
' weave are deprecated',
1035
type=get_format_type),
1036
]
1037
def run(self, location=None, format=None):
1038
if format is None:
1039
format = get_format_type('default')
1040
if location is None:
1041
location = u'.'
1042
1043
to_transport = transport.get_transport(location)
1044
1045
# The path has to exist to initialize a
1046
# branch inside of it.
1047
# Just using os.mkdir, since I don't
1048
# believe that we want to create a bunch of
1049
# locations if the user supplies an extended path
1050
# TODO: create-prefix
1051
try:
1052
to_transport.mkdir('.')
1053
except errors.FileExists:
1054
pass
1055
1056
try:
1057
existing_bzrdir = bzrdir.BzrDir.open(location)
1058
except NotBranchError:
1059
# really a NotBzrDir error...
1060
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1061
else:
1062
if existing_bzrdir.has_branch():
1063
if (isinstance(to_transport, LocalTransport)
1064
and not existing_bzrdir.has_workingtree()):
1065
raise errors.BranchExistsWithoutWorkingTree(location)
1066
raise errors.AlreadyBranchError(location)
1067
else:
1068
existing_bzrdir.create_branch()
1069
existing_bzrdir.create_workingtree()
1070
1071
1072
class cmd_init_repository(Command):
1073
"""Create a shared repository to hold branches.
1074
1075
New branches created under the repository directory will store their revisions
1076
in the repository, not in the branch directory, if the branch format supports
1077
shared storage.
1078
1079
example:
1080
bzr init-repo repo
1081
bzr init repo/trunk
1082
bzr checkout --lightweight repo/trunk trunk-checkout
1083
cd trunk-checkout
1084
(add files here)
1085
"""
1086
takes_args = ["location"]
1087
takes_options = [Option('format',
1088
help='Specify a format for this repository.'
1089
' Current formats are: default, knit,'
1090
' metaweave and weave. Default is knit;'
1091
' metaweave and weave are deprecated',
1092
type=get_format_type),
1093
Option('trees',
1094
help='Allows branches in repository to have'
1095
' a working tree')]
1096
aliases = ["init-repo"]
1097
def run(self, location, format=None, trees=False):
1098
if format is None:
1099
format = get_format_type('default')
1100
1101
if location is None:
1102
location = '.'
1103
1104
to_transport = transport.get_transport(location)
1105
try:
1106
to_transport.mkdir('.')
1107
except errors.FileExists:
1108
pass
1109
1110
newdir = format.initialize_on_transport(to_transport)
1111
repo = newdir.create_repository(shared=True)
1112
repo.set_make_working_trees(trees)
1113
1114
1115
class cmd_diff(Command):
1116
"""Show differences in the working tree or between revisions.
1117
1118
If files are listed, only the changes in those files are listed.
1119
Otherwise, all changes for the tree are listed.
1120
1121
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1122
produces patches suitable for "patch -p1".
1123
1124
examples:
1125
bzr diff
1126
Shows the difference in the working tree versus the last commit
1127
bzr diff -r1
1128
Difference between the working tree and revision 1
1129
bzr diff -r1..2
1130
Difference between revision 2 and revision 1
1131
bzr diff --diff-prefix old/:new/
1132
Same as 'bzr diff' but prefix paths with old/ and new/
1133
bzr diff bzr.mine bzr.dev
1134
Show the differences between the two working trees
1135
bzr diff foo.c
1136
Show just the differences for 'foo.c'
1137
"""
1138
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1139
# or a graphical diff.
1140
1141
# TODO: Python difflib is not exactly the same as unidiff; should
1142
# either fix it up or prefer to use an external diff.
1143
1144
# TODO: Selected-file diff is inefficient and doesn't show you
1145
# deleted files.
1146
1147
# TODO: This probably handles non-Unix newlines poorly.
1148
1149
takes_args = ['file*']
1150
takes_options = ['revision', 'diff-options', 'prefix']
1151
aliases = ['di', 'dif']
1152
encoding_type = 'exact'
1153
1154
@display_command
1155
def run(self, revision=None, file_list=None, diff_options=None,
1156
prefix=None):
1157
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1158
1159
if (prefix is None) or (prefix == '0'):
1160
# diff -p0 format
1161
old_label = ''
1162
new_label = ''
1163
elif prefix == '1':
1164
old_label = 'old/'
1165
new_label = 'new/'
1166
else:
1167
if not ':' in prefix:
1168
raise BzrError("--diff-prefix expects two values separated by a colon")
1169
old_label, new_label = prefix.split(":")
1170
1171
try:
1172
tree1, file_list = internal_tree_files(file_list)
1173
tree2 = None
1174
b = None
1175
b2 = None
1176
except FileInWrongBranch:
1177
if len(file_list) != 2:
1178
raise BzrCommandError("Files are in different branches")
1179
1180
tree1, file1 = WorkingTree.open_containing(file_list[0])
1181
tree2, file2 = WorkingTree.open_containing(file_list[1])
1182
if file1 != "" or file2 != "":
1183
# FIXME diff those two files. rbc 20051123
1184
raise BzrCommandError("Files are in different branches")
1185
file_list = None
1186
except NotBranchError:
1187
if (revision is not None and len(revision) == 2
1188
and not revision[0].needs_branch()
1189
and not revision[1].needs_branch()):
1190
# If both revision specs include a branch, we can
1191
# diff them without needing a local working tree
1192
tree1, tree2 = None, None
1193
else:
1194
raise
1195
if revision is not None:
1196
if tree2 is not None:
1197
raise BzrCommandError("Can't specify -r with two branches")
1198
if (len(revision) == 1) or (revision[1].spec is None):
1199
return diff_cmd_helper(tree1, file_list, diff_options,
1200
revision[0],
1201
old_label=old_label, new_label=new_label)
1202
elif len(revision) == 2:
1203
return diff_cmd_helper(tree1, file_list, diff_options,
1204
revision[0], revision[1],
1205
old_label=old_label, new_label=new_label)
1206
else:
1207
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1208
else:
1209
if tree2 is not None:
1210
return show_diff_trees(tree1, tree2, sys.stdout,
1211
specific_files=file_list,
1212
external_diff_options=diff_options,
1213
old_label=old_label, new_label=new_label)
1214
else:
1215
return diff_cmd_helper(tree1, file_list, diff_options,
1216
old_label=old_label, new_label=new_label)
1217
1218
1219
class cmd_deleted(Command):
1220
"""List files deleted in the working tree.
1221
"""
1222
# TODO: Show files deleted since a previous revision, or
1223
# between two revisions.
1224
# TODO: Much more efficient way to do this: read in new
1225
# directories with readdir, rather than stating each one. Same
1226
# level of effort but possibly much less IO. (Or possibly not,
1227
# if the directories are very large...)
1228
takes_options = ['show-ids']
1229
1230
@display_command
1231
def run(self, show_ids=False):
1232
tree = WorkingTree.open_containing(u'.')[0]
1233
old = tree.basis_tree()
1234
for path, ie in old.inventory.iter_entries():
1235
if not tree.has_id(ie.file_id):
1236
self.outf.write(path)
1237
if show_ids:
1238
self.outf.write(' ')
1239
self.outf.write(ie.file_id)
1240
self.outf.write('\n')
1241
1242
1243
class cmd_modified(Command):
1244
"""List files modified in working tree."""
1245
hidden = True
1246
@display_command
1247
def run(self):
1248
tree = WorkingTree.open_containing(u'.')[0]
1249
td = tree.changes_from(tree.basis_tree())
1250
for path, id, kind, text_modified, meta_modified in td.modified:
1251
self.outf.write(path + '\n')
1252
1253
1254
class cmd_added(Command):
1255
"""List files added in working tree."""
1256
hidden = True
1257
@display_command
1258
def run(self):
1259
wt = WorkingTree.open_containing(u'.')[0]
1260
basis_inv = wt.basis_tree().inventory
1261
inv = wt.inventory
1262
for file_id in inv:
1263
if file_id in basis_inv:
1264
continue
1265
path = inv.id2path(file_id)
1266
if not os.access(osutils.abspath(path), os.F_OK):
1267
continue
1268
self.outf.write(path + '\n')
1269
1270
1271
class cmd_root(Command):
1272
"""Show the tree root directory.
1273
1274
The root is the nearest enclosing directory with a .bzr control
1275
directory."""
1276
takes_args = ['filename?']
1277
@display_command
1278
def run(self, filename=None):
1279
"""Print the branch root."""
1280
tree = WorkingTree.open_containing(filename)[0]
1281
self.outf.write(tree.basedir + '\n')
1282
1283
1284
class cmd_log(Command):
1285
"""Show log of a branch, file, or directory.
1286
1287
By default show the log of the branch containing the working directory.
1288
1289
To request a range of logs, you can use the command -r begin..end
1290
-r revision requests a specific revision, -r ..end or -r begin.. are
1291
also valid.
1292
1293
examples:
1294
bzr log
1295
bzr log foo.c
1296
bzr log -r -10.. http://server/branch
1297
"""
1298
1299
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1300
1301
takes_args = ['location?']
1302
takes_options = [Option('forward',
1303
help='show from oldest to newest'),
1304
'timezone',
1305
Option('verbose',
1306
help='show files changed in each revision'),
1307
'show-ids', 'revision',
1308
'log-format',
1309
'line', 'long',
1310
Option('message',
1311
help='show revisions whose message matches this regexp',
1312
type=str),
1313
'short',
1314
]
1315
encoding_type = 'replace'
1316
1317
@display_command
1318
def run(self, location=None, timezone='original',
1319
verbose=False,
1320
show_ids=False,
1321
forward=False,
1322
revision=None,
1323
log_format=None,
1324
message=None,
1325
long=False,
1326
short=False,
1327
line=False):
1328
from bzrlib.log import log_formatter, show_log
1329
assert message is None or isinstance(message, basestring), \
1330
"invalid message argument %r" % message
1331
direction = (forward and 'forward') or 'reverse'
1332
1333
# log everything
1334
file_id = None
1335
if location:
1336
# find the file id to log:
1337
1338
dir, fp = bzrdir.BzrDir.open_containing(location)
1339
b = dir.open_branch()
1340
if fp != '':
1341
try:
1342
# might be a tree:
1343
inv = dir.open_workingtree().inventory
1344
except (errors.NotBranchError, errors.NotLocalUrl):
1345
# either no tree, or is remote.
1346
inv = b.basis_tree().inventory
1347
file_id = inv.path2id(fp)
1348
else:
1349
# local dir only
1350
# FIXME ? log the current subdir only RBC 20060203
1351
dir, relpath = bzrdir.BzrDir.open_containing('.')
1352
b = dir.open_branch()
1353
1354
if revision is None:
1355
rev1 = None
1356
rev2 = None
1357
elif len(revision) == 1:
1358
rev1 = rev2 = revision[0].in_history(b).revno
1359
elif len(revision) == 2:
1360
if revision[0].spec is None:
1361
# missing begin-range means first revision
1362
rev1 = 1
1363
else:
1364
rev1 = revision[0].in_history(b).revno
1365
1366
if revision[1].spec is None:
1367
# missing end-range means last known revision
1368
rev2 = b.revno()
1369
else:
1370
rev2 = revision[1].in_history(b).revno
1371
else:
1372
raise BzrCommandError('bzr log --revision takes one or two values.')
1373
1374
# By this point, the revision numbers are converted to the +ve
1375
# form if they were supplied in the -ve form, so we can do
1376
# this comparison in relative safety
1377
if rev1 > rev2:
1378
(rev2, rev1) = (rev1, rev2)
1379
1380
if (log_format is None):
1381
default = b.get_config().log_format()
1382
log_format = get_log_format(long=long, short=short, line=line,
1383
default=default)
1384
lf = log_formatter(log_format,
1385
show_ids=show_ids,
1386
to_file=self.outf,
1387
show_timezone=timezone)
1388
1389
show_log(b,
1390
lf,
1391
file_id,
1392
verbose=verbose,
1393
direction=direction,
1394
start_revision=rev1,
1395
end_revision=rev2,
1396
search=message)
1397
1398
1399
def get_log_format(long=False, short=False, line=False, default='long'):
1400
log_format = default
1401
if long:
1402
log_format = 'long'
1403
if short:
1404
log_format = 'short'
1405
if line:
1406
log_format = 'line'
1407
return log_format
1408
1409
1410
class cmd_touching_revisions(Command):
1411
"""Return revision-ids which affected a particular file.
1412
1413
A more user-friendly interface is "bzr log FILE".
1414
"""
1415
1416
hidden = True
1417
takes_args = ["filename"]
1418
1419
@display_command
1420
def run(self, filename):
1421
tree, relpath = WorkingTree.open_containing(filename)
1422
b = tree.branch
1423
inv = tree.read_working_inventory()
1424
file_id = inv.path2id(relpath)
1425
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1426
self.outf.write("%6d %s\n" % (revno, what))
1427
1428
1429
class cmd_ls(Command):
1430
"""List files in a tree.
1431
"""
1432
# TODO: Take a revision or remote path and list that tree instead.
1433
hidden = True
1434
takes_options = ['verbose', 'revision',
1435
Option('non-recursive',
1436
help='don\'t recurse into sub-directories'),
1437
Option('from-root',
1438
help='Print all paths from the root of the branch.'),
1439
Option('unknown', help='Print unknown files'),
1440
Option('versioned', help='Print versioned files'),
1441
Option('ignored', help='Print ignored files'),
1442
1443
Option('null', help='Null separate the files'),
1444
]
1445
@display_command
1446
def run(self, revision=None, verbose=False,
1447
non_recursive=False, from_root=False,
1448
unknown=False, versioned=False, ignored=False,
1449
null=False):
1450
1451
if verbose and null:
1452
raise BzrCommandError('Cannot set both --verbose and --null')
1453
all = not (unknown or versioned or ignored)
1454
1455
selection = {'I':ignored, '?':unknown, 'V':versioned}
1456
1457
tree, relpath = WorkingTree.open_containing(u'.')
1458
if from_root:
1459
relpath = u''
1460
elif relpath:
1461
relpath += '/'
1462
if revision is not None:
1463
tree = tree.branch.repository.revision_tree(
1464
revision[0].in_history(tree.branch).rev_id)
1465
1466
for fp, fc, kind, fid, entry in tree.list_files():
1467
if fp.startswith(relpath):
1468
fp = fp[len(relpath):]
1469
if non_recursive and '/' in fp:
1470
continue
1471
if not all and not selection[fc]:
1472
continue
1473
if verbose:
1474
kindch = entry.kind_character()
1475
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1476
elif null:
1477
self.outf.write(fp + '\0')
1478
self.outf.flush()
1479
else:
1480
self.outf.write(fp + '\n')
1481
1482
1483
class cmd_unknowns(Command):
1484
"""List unknown files."""
1485
@display_command
1486
def run(self):
1487
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1488
self.outf.write(osutils.quotefn(f) + '\n')
1489
1490
1491
class cmd_ignore(Command):
1492
"""Ignore a command or pattern.
1493
1494
To remove patterns from the ignore list, edit the .bzrignore file.
1495
1496
If the pattern contains a slash, it is compared to the whole path
1497
from the branch root. Otherwise, it is compared to only the last
1498
component of the path. To match a file only in the root directory,
1499
prepend './'.
1500
1501
Ignore patterns are case-insensitive on case-insensitive systems.
1502
1503
Note: wildcards must be quoted from the shell on Unix.
1504
1505
examples:
1506
bzr ignore ./Makefile
1507
bzr ignore '*.class'
1508
"""
1509
# TODO: Complain if the filename is absolute
1510
takes_args = ['name_pattern?']
1511
takes_options = [
1512
Option('old-default-rules',
1513
help='Out the ignore rules bzr < 0.9 always used.')
1514
]
1515
1516
def run(self, name_pattern=None, old_default_rules=None):
1517
from bzrlib.atomicfile import AtomicFile
1518
if old_default_rules is not None:
1519
# dump the rules and exit
1520
for pattern in ignores.OLD_DEFAULTS:
1521
print pattern
1522
return
1523
if name_pattern is None:
1524
raise BzrCommandError("ignore requires a NAME_PATTERN")
1525
tree, relpath = WorkingTree.open_containing(u'.')
1526
ifn = tree.abspath('.bzrignore')
1527
if os.path.exists(ifn):
1528
f = open(ifn, 'rt')
1529
try:
1530
igns = f.read().decode('utf-8')
1531
finally:
1532
f.close()
1533
else:
1534
igns = ''
1535
1536
# TODO: If the file already uses crlf-style termination, maybe
1537
# we should use that for the newly added lines?
1538
1539
if igns and igns[-1] != '\n':
1540
igns += '\n'
1541
igns += name_pattern + '\n'
1542
1543
f = AtomicFile(ifn, 'wt')
1544
try:
1545
f.write(igns.encode('utf-8'))
1546
f.commit()
1547
finally:
1548
f.close()
1549
1550
inv = tree.inventory
1551
if inv.path2id('.bzrignore'):
1552
mutter('.bzrignore is already versioned')
1553
else:
1554
mutter('need to make new .bzrignore file versioned')
1555
tree.add(['.bzrignore'])
1556
1557
1558
class cmd_ignored(Command):
1559
"""List ignored files and the patterns that matched them.
1560
1561
See also: bzr ignore"""
1562
@display_command
1563
def run(self):
1564
tree = WorkingTree.open_containing(u'.')[0]
1565
for path, file_class, kind, file_id, entry in tree.list_files():
1566
if file_class != 'I':
1567
continue
1568
## XXX: Slightly inefficient since this was already calculated
1569
pat = tree.is_ignored(path)
1570
print '%-50s %s' % (path, pat)
1571
1572
1573
class cmd_lookup_revision(Command):
1574
"""Lookup the revision-id from a revision-number
1575
1576
example:
1577
bzr lookup-revision 33
1578
"""
1579
hidden = True
1580
takes_args = ['revno']
1581
1582
@display_command
1583
def run(self, revno):
1584
try:
1585
revno = int(revno)
1586
except ValueError:
1587
raise BzrCommandError("not a valid revision-number: %r" % revno)
1588
1589
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1590
1591
1592
class cmd_export(Command):
1593
"""Export past revision to destination directory.
1594
1595
If no revision is specified this exports the last committed revision.
1596
1597
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1598
given, try to find the format with the extension. If no extension
1599
is found exports to a directory (equivalent to --format=dir).
1600
1601
Root may be the top directory for tar, tgz and tbz2 formats. If none
1602
is given, the top directory will be the root name of the file.
1603
1604
Note: export of tree with non-ascii filenames to zip is not supported.
1605
1606
Supported formats Autodetected by extension
1607
----------------- -------------------------
1608
dir -
1609
tar .tar
1610
tbz2 .tar.bz2, .tbz2
1611
tgz .tar.gz, .tgz
1612
zip .zip
1613
"""
1614
takes_args = ['dest']
1615
takes_options = ['revision', 'format', 'root']
1616
def run(self, dest, revision=None, format=None, root=None):
1617
from bzrlib.export import export
1618
tree = WorkingTree.open_containing(u'.')[0]
1619
b = tree.branch
1620
if revision is None:
1621
# should be tree.last_revision FIXME
1622
rev_id = b.last_revision()
1623
else:
1624
if len(revision) != 1:
1625
raise BzrError('bzr export --revision takes exactly 1 argument')
1626
rev_id = revision[0].in_history(b).rev_id
1627
t = b.repository.revision_tree(rev_id)
1628
try:
1629
export(t, dest, format, root)
1630
except errors.NoSuchExportFormat, e:
1631
raise BzrCommandError('Unsupported export format: %s' % e.format)
1632
1633
1634
class cmd_cat(Command):
1635
"""Write a file's text from a previous revision."""
1636
1637
takes_options = ['revision']
1638
takes_args = ['filename']
1639
1640
@display_command
1641
def run(self, filename, revision=None):
1642
if revision is not None and len(revision) != 1:
1643
raise BzrCommandError("bzr cat --revision takes exactly one number")
1644
tree = None
1645
try:
1646
tree, relpath = WorkingTree.open_containing(filename)
1647
b = tree.branch
1648
except NotBranchError:
1649
pass
1650
1651
if tree is None:
1652
b, relpath = Branch.open_containing(filename)
1653
if revision is None:
1654
revision_id = b.last_revision()
1655
else:
1656
revision_id = revision[0].in_history(b).rev_id
1657
b.print_file(relpath, revision_id)
1658
1659
1660
class cmd_local_time_offset(Command):
1661
"""Show the offset in seconds from GMT to local time."""
1662
hidden = True
1663
@display_command
1664
def run(self):
1665
print osutils.local_time_offset()
1666
1667
1668
1669
class cmd_commit(Command):
1670
"""Commit changes into a new revision.
1671
1672
If no arguments are given, the entire tree is committed.
1673
1674
If selected files are specified, only changes to those files are
1675
committed. If a directory is specified then the directory and everything
1676
within it is committed.
1677
1678
A selected-file commit may fail in some cases where the committed
1679
tree would be invalid, such as trying to commit a file in a
1680
newly-added directory that is not itself committed.
1681
"""
1682
# TODO: Run hooks on tree to-be-committed, and after commit.
1683
1684
# TODO: Strict commit that fails if there are deleted files.
1685
# (what does "deleted files" mean ??)
1686
1687
# TODO: Give better message for -s, --summary, used by tla people
1688
1689
# XXX: verbose currently does nothing
1690
1691
takes_args = ['selected*']
1692
takes_options = ['message', 'verbose',
1693
Option('unchanged',
1694
help='commit even if nothing has changed'),
1695
Option('file', type=str,
1696
argname='msgfile',
1697
help='file containing commit message'),
1698
Option('strict',
1699
help="refuse to commit if there are unknown "
1700
"files in the working tree."),
1701
Option('local',
1702
help="perform a local only commit in a bound "
1703
"branch. Such commits are not pushed to "
1704
"the master branch until a normal commit "
1705
"is performed."
1706
),
1707
]
1708
aliases = ['ci', 'checkin']
1709
1710
def run(self, message=None, file=None, verbose=True, selected_list=None,
1711
unchanged=False, strict=False, local=False):
1712
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1713
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1714
StrictCommitFailed)
1715
from bzrlib.msgeditor import edit_commit_message, \
1716
make_commit_message_template
1717
from tempfile import TemporaryFile
1718
1719
# TODO: Need a blackbox test for invoking the external editor; may be
1720
# slightly problematic to run this cross-platform.
1721
1722
# TODO: do more checks that the commit will succeed before
1723
# spending the user's valuable time typing a commit message.
1724
#
1725
# TODO: if the commit *does* happen to fail, then save the commit
1726
# message to a temporary file where it can be recovered
1727
tree, selected_list = tree_files(selected_list)
1728
if selected_list == ['']:
1729
# workaround - commit of root of tree should be exactly the same
1730
# as just default commit in that tree, and succeed even though
1731
# selected-file merge commit is not done yet
1732
selected_list = []
1733
1734
if local and not tree.branch.get_bound_location():
1735
raise errors.LocalRequiresBoundBranch()
1736
if message is None and not file:
1737
template = make_commit_message_template(tree, selected_list)
1738
message = edit_commit_message(template)
1739
if message is None:
1740
raise BzrCommandError("please specify a commit message"
1741
" with either --message or --file")
1742
elif message and file:
1743
raise BzrCommandError("please specify either --message or --file")
1744
1745
if file:
1746
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1747
1748
if message == "":
1749
raise BzrCommandError("empty commit message specified")
1750
1751
if verbose:
1752
reporter = ReportCommitToLog()
1753
else:
1754
reporter = NullCommitReporter()
1755
1756
try:
1757
tree.commit(message, specific_files=selected_list,
1758
allow_pointless=unchanged, strict=strict, local=local,
1759
reporter=reporter)
1760
except PointlessCommit:
1761
# FIXME: This should really happen before the file is read in;
1762
# perhaps prepare the commit; get the message; then actually commit
1763
raise BzrCommandError("no changes to commit."
1764
" use --unchanged to commit anyhow")
1765
except ConflictsInTree:
1766
raise BzrCommandError("Conflicts detected in working tree. "
1767
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1768
except StrictCommitFailed:
1769
raise BzrCommandError("Commit refused because there are unknown "
1770
"files in the working tree.")
1771
except errors.BoundBranchOutOfDate, e:
1772
raise BzrCommandError(str(e) + "\n"
1773
'To commit to master branch, run update and then commit.\n'
1774
'You can also pass --local to commit to continue working '
1775
'disconnected.')
1776
1777
class cmd_check(Command):
1778
"""Validate consistency of branch history.
1779
1780
This command checks various invariants about the branch storage to
1781
detect data corruption or bzr bugs.
1782
"""
1783
takes_args = ['branch?']
1784
takes_options = ['verbose']
1785
1786
def run(self, branch=None, verbose=False):
1787
from bzrlib.check import check
1788
if branch is None:
1789
tree = WorkingTree.open_containing()[0]
1790
branch = tree.branch
1791
else:
1792
branch = Branch.open(branch)
1793
check(branch, verbose)
1794
1795
1796
class cmd_scan_cache(Command):
1797
hidden = True
1798
def run(self):
1799
from bzrlib.hashcache import HashCache
1800
1801
c = HashCache(u'.')
1802
c.read()
1803
c.scan()
1804
1805
print '%6d stats' % c.stat_count
1806
print '%6d in hashcache' % len(c._cache)
1807
print '%6d files removed from cache' % c.removed_count
1808
print '%6d hashes updated' % c.update_count
1809
print '%6d files changed too recently to cache' % c.danger_count
1810
1811
if c.needs_write:
1812
c.write()
1813
1814
1815
class cmd_upgrade(Command):
1816
"""Upgrade branch storage to current format.
1817
1818
The check command or bzr developers may sometimes advise you to run
1819
this command. When the default format has changed you may also be warned
1820
during other operations to upgrade.
1821
"""
1822
takes_args = ['url?']
1823
takes_options = [
1824
Option('format',
1825
help='Upgrade to a specific format. Current formats'
1826
' are: default, knit, metaweave and weave.'
1827
' Default is knit; metaweave and weave are'
1828
' deprecated',
1829
type=get_format_type),
1830
]
1831
1832
1833
def run(self, url='.', format=None):
1834
from bzrlib.upgrade import upgrade
1835
if format is None:
1836
format = get_format_type('default')
1837
upgrade(url, format)
1838
1839
1840
class cmd_whoami(Command):
1841
"""Show or set bzr user id.
1842
1843
examples:
1844
bzr whoami --email
1845
bzr whoami 'Frank Chu <fchu@example.com>'
1846
"""
1847
takes_options = [ Option('email',
1848
help='display email address only'),
1849
Option('branch',
1850
help='set identity for the current branch instead of '
1851
'globally'),
1852
]
1853
takes_args = ['name?']
1854
encoding_type = 'replace'
1855
1856
@display_command
1857
def run(self, email=False, branch=False, name=None):
1858
if name is None:
1859
# use branch if we're inside one; otherwise global config
1860
try:
1861
c = Branch.open_containing('.')[0].get_config()
1862
except NotBranchError:
1863
c = config.GlobalConfig()
1864
if email:
1865
self.outf.write(c.user_email() + '\n')
1866
else:
1867
self.outf.write(c.username() + '\n')
1868
return
1869
1870
# display a warning if an email address isn't included in the given name.
1871
try:
1872
config.extract_email_address(name)
1873
except BzrError, e:
1874
warning('"%s" does not seem to contain an email address. '
1875
'This is allowed, but not recommended.', name)
1876
1877
# use global config unless --branch given
1878
if branch:
1879
c = Branch.open_containing('.')[0].get_config()
1880
else:
1881
c = config.GlobalConfig()
1882
c.set_user_option('email', name)
1883
1884
1885
class cmd_nick(Command):
1886
"""Print or set the branch nickname.
1887
1888
If unset, the tree root directory name is used as the nickname
1889
To print the current nickname, execute with no argument.
1890
"""
1891
takes_args = ['nickname?']
1892
def run(self, nickname=None):
1893
branch = Branch.open_containing(u'.')[0]
1894
if nickname is None:
1895
self.printme(branch)
1896
else:
1897
branch.nick = nickname
1898
1899
@display_command
1900
def printme(self, branch):
1901
print branch.nick
1902
1903
1904
class cmd_selftest(Command):
1905
"""Run internal test suite.
1906
1907
This creates temporary test directories in the working directory,
1908
but not existing data is affected. These directories are deleted
1909
if the tests pass, or left behind to help in debugging if they
1910
fail and --keep-output is specified.
1911
1912
If arguments are given, they are regular expressions that say
1913
which tests should run.
1914
1915
If the global option '--no-plugins' is given, plugins are not loaded
1916
before running the selftests. This has two effects: features provided or
1917
modified by plugins will not be tested, and tests provided by plugins will
1918
not be run.
1919
1920
examples:
1921
bzr selftest ignore
1922
bzr --no-plugins selftest -v
1923
"""
1924
# TODO: --list should give a list of all available tests
1925
1926
# NB: this is used from the class without creating an instance, which is
1927
# why it does not have a self parameter.
1928
def get_transport_type(typestring):
1929
"""Parse and return a transport specifier."""
1930
if typestring == "sftp":
1931
from bzrlib.transport.sftp import SFTPAbsoluteServer
1932
return SFTPAbsoluteServer
1933
if typestring == "memory":
1934
from bzrlib.transport.memory import MemoryServer
1935
return MemoryServer
1936
if typestring == "fakenfs":
1937
from bzrlib.transport.fakenfs import FakeNFSServer
1938
return FakeNFSServer
1939
msg = "No known transport type %s. Supported types are: sftp\n" %\
1940
(typestring)
1941
raise BzrCommandError(msg)
1942
1943
hidden = True
1944
takes_args = ['testspecs*']
1945
takes_options = ['verbose',
1946
Option('one', help='stop when one test fails'),
1947
Option('keep-output',
1948
help='keep output directories when tests fail'),
1949
Option('transport',
1950
help='Use a different transport by default '
1951
'throughout the test suite.',
1952
type=get_transport_type),
1953
Option('benchmark', help='run the bzr bencharks.'),
1954
Option('lsprof-timed',
1955
help='generate lsprof output for benchmarked'
1956
' sections of code.'),
1957
Option('cache-dir', type=str,
1958
help='a directory to cache intermediate'
1959
' benchmark steps'),
1960
]
1961
1962
def run(self, testspecs_list=None, verbose=None, one=False,
1963
keep_output=False, transport=None, benchmark=None,
1964
lsprof_timed=None, cache_dir=None):
1965
import bzrlib.ui
1966
from bzrlib.tests import selftest
1967
import bzrlib.benchmarks as benchmarks
1968
from bzrlib.benchmarks import tree_creator
1969
1970
if cache_dir is not None:
1971
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
1972
# we don't want progress meters from the tests to go to the
1973
# real output; and we don't want log messages cluttering up
1974
# the real logs.
1975
save_ui = ui.ui_factory
1976
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1977
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1978
print
1979
info('running tests...')
1980
try:
1981
ui.ui_factory = ui.SilentUIFactory()
1982
if testspecs_list is not None:
1983
pattern = '|'.join(testspecs_list)
1984
else:
1985
pattern = ".*"
1986
if benchmark:
1987
test_suite_factory = benchmarks.test_suite
1988
if verbose is None:
1989
verbose = True
1990
benchfile = open(".perf_history", "at")
1991
else:
1992
test_suite_factory = None
1993
if verbose is None:
1994
verbose = False
1995
benchfile = None
1996
try:
1997
result = selftest(verbose=verbose,
1998
pattern=pattern,
1999
stop_on_failure=one,
2000
keep_output=keep_output,
2001
transport=transport,
2002
test_suite_factory=test_suite_factory,
2003
lsprof_timed=lsprof_timed,
2004
bench_history=benchfile)
2005
finally:
2006
if benchfile is not None:
2007
benchfile.close()
2008
if result:
2009
info('tests passed')
2010
else:
2011
info('tests failed')
2012
return int(not result)
2013
finally:
2014
ui.ui_factory = save_ui
2015
2016
2017
class cmd_version(Command):
2018
"""Show version of bzr."""
2019
2020
@display_command
2021
def run(self):
2022
from bzrlib.version import show_version
2023
show_version()
2024
2025
2026
class cmd_rocks(Command):
2027
"""Statement of optimism."""
2028
2029
hidden = True
2030
2031
@display_command
2032
def run(self):
2033
print "it sure does!"
2034
2035
2036
class cmd_find_merge_base(Command):
2037
"""Find and print a base revision for merging two branches."""
2038
# TODO: Options to specify revisions on either side, as if
2039
# merging only part of the history.
2040
takes_args = ['branch', 'other']
2041
hidden = True
2042
2043
@display_command
2044
def run(self, branch, other):
2045
from bzrlib.revision import MultipleRevisionSources
2046
2047
branch1 = Branch.open_containing(branch)[0]
2048
branch2 = Branch.open_containing(other)[0]
2049
2050
history_1 = branch1.revision_history()
2051
history_2 = branch2.revision_history()
2052
2053
last1 = branch1.last_revision()
2054
last2 = branch2.last_revision()
2055
2056
source = MultipleRevisionSources(branch1.repository,
2057
branch2.repository)
2058
2059
base_rev_id = common_ancestor(last1, last2, source)
2060
2061
print 'merge base is revision %s' % base_rev_id
2062
2063
2064
class cmd_merge(Command):
2065
"""Perform a three-way merge.
2066
2067
The branch is the branch you will merge from. By default, it will merge
2068
the latest revision. If you specify a revision, that revision will be
2069
merged. If you specify two revisions, the first will be used as a BASE,
2070
and the second one as OTHER. Revision numbers are always relative to the
2071
specified branch.
2072
2073
By default, bzr will try to merge in all new work from the other
2074
branch, automatically determining an appropriate base. If this
2075
fails, you may need to give an explicit base.
2076
2077
Merge will do its best to combine the changes in two branches, but there
2078
are some kinds of problems only a human can fix. When it encounters those,
2079
it will mark a conflict. A conflict means that you need to fix something,
2080
before you should commit.
2081
2082
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2083
2084
If there is no default branch set, the first merge will set it. After
2085
that, you can omit the branch to use the default. To change the
2086
default, use --remember. The value will only be saved if the remote
2087
location can be accessed.
2088
2089
Examples:
2090
2091
To merge the latest revision from bzr.dev
2092
bzr merge ../bzr.dev
2093
2094
To merge changes up to and including revision 82 from bzr.dev
2095
bzr merge -r 82 ../bzr.dev
2096
2097
To merge the changes introduced by 82, without previous changes:
2098
bzr merge -r 81..82 ../bzr.dev
2099
2100
merge refuses to run if there are any uncommitted changes, unless
2101
--force is given.
2102
2103
The following merge types are available:
2104
"""
2105
takes_args = ['branch?']
2106
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2107
Option('show-base', help="Show base revision text in "
2108
"conflicts"),
2109
Option('uncommitted', help='Apply uncommitted changes'
2110
' from a working copy, instead of branch changes')]
2111
2112
def help(self):
2113
from inspect import getdoc
2114
return getdoc(self) + '\n' + _mod_merge.merge_type_help()
2115
2116
def run(self, branch=None, revision=None, force=False, merge_type=None,
2117
show_base=False, reprocess=False, remember=False,
2118
uncommitted=False):
2119
if merge_type is None:
2120
merge_type = _mod_merge.Merge3Merger
2121
2122
tree = WorkingTree.open_containing(u'.')[0]
2123
2124
if branch is not None:
2125
try:
2126
reader = bundle.read_bundle_from_url(branch)
2127
except NotABundle:
2128
pass # Continue on considering this url a Branch
2129
else:
2130
conflicts = merge_bundle(reader, tree, not force, merge_type,
2131
reprocess, show_base)
2132
if conflicts == 0:
2133
return 0
2134
else:
2135
return 1
2136
2137
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2138
2139
if revision is None or len(revision) < 1:
2140
if uncommitted:
2141
base = [branch, -1]
2142
other = [branch, None]
2143
else:
2144
base = [None, None]
2145
other = [branch, -1]
2146
other_branch, path = Branch.open_containing(branch)
2147
else:
2148
if uncommitted:
2149
raise BzrCommandError('Cannot use --uncommitted and --revision'
2150
' at the same time.')
2151
if len(revision) == 1:
2152
base = [None, None]
2153
other_branch, path = Branch.open_containing(branch)
2154
revno = revision[0].in_history(other_branch).revno
2155
other = [branch, revno]
2156
else:
2157
assert len(revision) == 2
2158
if None in revision:
2159
raise BzrCommandError(
2160
"Merge doesn't permit that revision specifier.")
2161
other_branch, path = Branch.open_containing(branch)
2162
2163
base = [branch, revision[0].in_history(other_branch).revno]
2164
other = [branch, revision[1].in_history(other_branch).revno]
2165
2166
if tree.branch.get_parent() is None or remember:
2167
tree.branch.set_parent(other_branch.base)
2168
2169
if path != "":
2170
interesting_files = [path]
2171
else:
2172
interesting_files = None
2173
pb = ui.ui_factory.nested_progress_bar()
2174
try:
2175
try:
2176
conflict_count = _merge_helper(
2177
other, base, check_clean=(not force),
2178
merge_type=merge_type,
2179
reprocess=reprocess,
2180
show_base=show_base,
2181
pb=pb, file_list=interesting_files)
2182
finally:
2183
pb.finished()
2184
if conflict_count != 0:
2185
return 1
2186
else:
2187
return 0
2188
except errors.AmbiguousBase, e:
2189
m = ("sorry, bzr can't determine the right merge base yet\n"
2190
"candidates are:\n "
2191
+ "\n ".join(e.bases)
2192
+ "\n"
2193
"please specify an explicit base with -r,\n"
2194
"and (if you want) report this to the bzr developers\n")
2195
log_error(m)
2196
2197
# TODO: move up to common parent; this isn't merge-specific anymore.
2198
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2199
"""Use tree.branch's parent if none was supplied.
2200
2201
Report if the remembered location was used.
2202
"""
2203
if supplied_location is not None:
2204
return supplied_location
2205
stored_location = tree.branch.get_parent()
2206
mutter("%s", stored_location)
2207
if stored_location is None:
2208
raise BzrCommandError("No location specified or remembered")
2209
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2210
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2211
return stored_location
2212
2213
2214
class cmd_remerge(Command):
2215
"""Redo a merge.
2216
2217
Use this if you want to try a different merge technique while resolving
2218
conflicts. Some merge techniques are better than others, and remerge
2219
lets you try different ones on different files.
2220
2221
The options for remerge have the same meaning and defaults as the ones for
2222
merge. The difference is that remerge can (only) be run when there is a
2223
pending merge, and it lets you specify particular files.
2224
2225
Examples:
2226
$ bzr remerge --show-base
2227
Re-do the merge of all conflicted files, and show the base text in
2228
conflict regions, in addition to the usual THIS and OTHER texts.
2229
2230
$ bzr remerge --merge-type weave --reprocess foobar
2231
Re-do the merge of "foobar", using the weave merge algorithm, with
2232
additional processing to reduce the size of conflict regions.
2233
2234
The following merge types are available:"""
2235
takes_args = ['file*']
2236
takes_options = ['merge-type', 'reprocess',
2237
Option('show-base', help="Show base revision text in "
2238
"conflicts")]
2239
2240
def help(self):
2241
from inspect import getdoc
2242
return getdoc(self) + '\n' + _mod_merge.merge_type_help()
2243
2244
def run(self, file_list=None, merge_type=None, show_base=False,
2245
reprocess=False):
2246
if merge_type is None:
2247
merge_type = _mod_merge.Merge3Merger
2248
tree, file_list = tree_files(file_list)
2249
tree.lock_write()
2250
try:
2251
parents = tree.get_parent_ids()
2252
if len(parents) != 2:
2253
raise BzrCommandError("Sorry, remerge only works after normal"
2254
" merges. Not cherrypicking or"
2255
" multi-merges.")
2256
repository = tree.branch.repository
2257
base_revision = common_ancestor(parents[0],
2258
parents[1], repository)
2259
base_tree = repository.revision_tree(base_revision)
2260
other_tree = repository.revision_tree(parents[1])
2261
interesting_ids = None
2262
new_conflicts = []
2263
conflicts = tree.conflicts()
2264
if file_list is not None:
2265
interesting_ids = set()
2266
for filename in file_list:
2267
file_id = tree.path2id(filename)
2268
if file_id is None:
2269
raise NotVersionedError(filename)
2270
interesting_ids.add(file_id)
2271
if tree.kind(file_id) != "directory":
2272
continue
2273
2274
for name, ie in tree.inventory.iter_entries(file_id):
2275
interesting_ids.add(ie.file_id)
2276
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2277
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2278
tree.set_conflicts(ConflictList(new_conflicts))
2279
if file_list is None:
2280
restore_files = list(tree.iter_conflicts())
2281
else:
2282
restore_files = file_list
2283
for filename in restore_files:
2284
try:
2285
restore(tree.abspath(filename))
2286
except NotConflicted:
2287
pass
2288
conflicts = _mod_merge.merge_inner(
2289
tree.branch, other_tree, base_tree,
2290
this_tree=tree,
2291
interesting_ids=interesting_ids,
2292
other_rev_id=parents[1],
2293
merge_type=merge_type,
2294
show_base=show_base,
2295
reprocess=reprocess)
2296
finally:
2297
tree.unlock()
2298
if conflicts > 0:
2299
return 1
2300
else:
2301
return 0
2302
2303
class cmd_revert(Command):
2304
"""Reverse all changes since the last commit.
2305
2306
Only versioned files are affected. Specify filenames to revert only
2307
those files. By default, any files that are changed will be backed up
2308
first. Backup files have a '~' appended to their name.
2309
"""
2310
takes_options = ['revision', 'no-backup']
2311
takes_args = ['file*']
2312
aliases = ['merge-revert']
2313
2314
def run(self, revision=None, no_backup=False, file_list=None):
2315
if file_list is not None:
2316
if len(file_list) == 0:
2317
raise BzrCommandError("No files specified")
2318
else:
2319
file_list = []
2320
2321
tree, file_list = tree_files(file_list)
2322
if revision is None:
2323
# FIXME should be tree.last_revision
2324
rev_id = tree.last_revision()
2325
elif len(revision) != 1:
2326
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2327
else:
2328
rev_id = revision[0].in_history(tree.branch).rev_id
2329
pb = ui.ui_factory.nested_progress_bar()
2330
try:
2331
tree.revert(file_list,
2332
tree.branch.repository.revision_tree(rev_id),
2333
not no_backup, pb)
2334
finally:
2335
pb.finished()
2336
2337
2338
class cmd_assert_fail(Command):
2339
"""Test reporting of assertion failures"""
2340
hidden = True
2341
def run(self):
2342
assert False, "always fails"
2343
2344
2345
class cmd_help(Command):
2346
"""Show help on a command or other topic.
2347
2348
For a list of all available commands, say 'bzr help commands'."""
2349
takes_options = [Option('long', 'show help on all commands')]
2350
takes_args = ['topic?']
2351
aliases = ['?', '--help', '-?', '-h']
2352
2353
@display_command
2354
def run(self, topic=None, long=False):
2355
import help
2356
if topic is None and long:
2357
topic = "commands"
2358
help.help(topic)
2359
2360
2361
class cmd_shell_complete(Command):
2362
"""Show appropriate completions for context.
2363
2364
For a list of all available commands, say 'bzr shell-complete'."""
2365
takes_args = ['context?']
2366
aliases = ['s-c']
2367
hidden = True
2368
2369
@display_command
2370
def run(self, context=None):
2371
import shellcomplete
2372
shellcomplete.shellcomplete(context)
2373
2374
2375
class cmd_fetch(Command):
2376
"""Copy in history from another branch but don't merge it.
2377
2378
This is an internal method used for pull and merge."""
2379
hidden = True
2380
takes_args = ['from_branch', 'to_branch']
2381
def run(self, from_branch, to_branch):
2382
from bzrlib.fetch import Fetcher
2383
from_b = Branch.open(from_branch)
2384
to_b = Branch.open(to_branch)
2385
Fetcher(to_b, from_b)
2386
2387
2388
class cmd_missing(Command):
2389
"""Show unmerged/unpulled revisions between two branches.
2390
2391
OTHER_BRANCH may be local or remote."""
2392
takes_args = ['other_branch?']
2393
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2394
Option('mine-only',
2395
'Display changes in the local branch only'),
2396
Option('theirs-only',
2397
'Display changes in the remote branch only'),
2398
'log-format',
2399
'line',
2400
'long',
2401
'short',
2402
'show-ids',
2403
'verbose'
2404
]
2405
encoding_type = 'replace'
2406
2407
@display_command
2408
def run(self, other_branch=None, reverse=False, mine_only=False,
2409
theirs_only=False, log_format=None, long=False, short=False, line=False,
2410
show_ids=False, verbose=False):
2411
from bzrlib.missing import find_unmerged, iter_log_data
2412
from bzrlib.log import log_formatter
2413
local_branch = Branch.open_containing(u".")[0]
2414
parent = local_branch.get_parent()
2415
if other_branch is None:
2416
other_branch = parent
2417
if other_branch is None:
2418
raise BzrCommandError("No peer location known or specified.")
2419
print "Using last location: " + local_branch.get_parent()
2420
remote_branch = Branch.open(other_branch)
2421
if remote_branch.base == local_branch.base:
2422
remote_branch = local_branch
2423
local_branch.lock_read()
2424
try:
2425
remote_branch.lock_read()
2426
try:
2427
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2428
if (log_format is None):
2429
default = local_branch.get_config().log_format()
2430
log_format = get_log_format(long=long, short=short,
2431
line=line, default=default)
2432
lf = log_formatter(log_format,
2433
to_file=self.outf,
2434
show_ids=show_ids,
2435
show_timezone='original')
2436
if reverse is False:
2437
local_extra.reverse()
2438
remote_extra.reverse()
2439
if local_extra and not theirs_only:
2440
print "You have %d extra revision(s):" % len(local_extra)
2441
for data in iter_log_data(local_extra, local_branch.repository,
2442
verbose):
2443
lf.show(*data)
2444
printed_local = True
2445
else:
2446
printed_local = False
2447
if remote_extra and not mine_only:
2448
if printed_local is True:
2449
print "\n\n"
2450
print "You are missing %d revision(s):" % len(remote_extra)
2451
for data in iter_log_data(remote_extra, remote_branch.repository,
2452
verbose):
2453
lf.show(*data)
2454
if not remote_extra and not local_extra:
2455
status_code = 0
2456
print "Branches are up to date."
2457
else:
2458
status_code = 1
2459
finally:
2460
remote_branch.unlock()
2461
finally:
2462
local_branch.unlock()
2463
if not status_code and parent is None and other_branch is not None:
2464
local_branch.lock_write()
2465
try:
2466
# handle race conditions - a parent might be set while we run.
2467
if local_branch.get_parent() is None:
2468
local_branch.set_parent(remote_branch.base)
2469
finally:
2470
local_branch.unlock()
2471
return status_code
2472
2473
2474
class cmd_plugins(Command):
2475
"""List plugins"""
2476
hidden = True
2477
@display_command
2478
def run(self):
2479
import bzrlib.plugin
2480
from inspect import getdoc
2481
for name, plugin in bzrlib.plugin.all_plugins().items():
2482
if getattr(plugin, '__path__', None) is not None:
2483
print plugin.__path__[0]
2484
elif getattr(plugin, '__file__', None) is not None:
2485
print plugin.__file__
2486
else:
2487
print repr(plugin)
2488
2489
d = getdoc(plugin)
2490
if d:
2491
print '\t', d.split('\n')[0]
2492
2493
2494
class cmd_testament(Command):
2495
"""Show testament (signing-form) of a revision."""
2496
takes_options = ['revision',
2497
Option('long', help='Produce long-format testament'),
2498
Option('strict', help='Produce a strict-format'
2499
' testament')]
2500
takes_args = ['branch?']
2501
@display_command
2502
def run(self, branch=u'.', revision=None, long=False, strict=False):
2503
from bzrlib.testament import Testament, StrictTestament
2504
if strict is True:
2505
testament_class = StrictTestament
2506
else:
2507
testament_class = Testament
2508
b = WorkingTree.open_containing(branch)[0].branch
2509
b.lock_read()
2510
try:
2511
if revision is None:
2512
rev_id = b.last_revision()
2513
else:
2514
rev_id = revision[0].in_history(b).rev_id
2515
t = testament_class.from_revision(b.repository, rev_id)
2516
if long:
2517
sys.stdout.writelines(t.as_text_lines())
2518
else:
2519
sys.stdout.write(t.as_short_text())
2520
finally:
2521
b.unlock()
2522
2523
2524
class cmd_annotate(Command):
2525
"""Show the origin of each line in a file.
2526
2527
This prints out the given file with an annotation on the left side
2528
indicating which revision, author and date introduced the change.
2529
2530
If the origin is the same for a run of consecutive lines, it is
2531
shown only at the top, unless the --all option is given.
2532
"""
2533
# TODO: annotate directories; showing when each file was last changed
2534
# TODO: if the working copy is modified, show annotations on that
2535
# with new uncommitted lines marked
2536
aliases = ['ann', 'blame', 'praise']
2537
takes_args = ['filename']
2538
takes_options = [Option('all', help='show annotations on all lines'),
2539
Option('long', help='show date in annotations'),
2540
'revision'
2541
]
2542
2543
@display_command
2544
def run(self, filename, all=False, long=False, revision=None):
2545
from bzrlib.annotate import annotate_file
2546
tree, relpath = WorkingTree.open_containing(filename)
2547
branch = tree.branch
2548
branch.lock_read()
2549
try:
2550
if revision is None:
2551
revision_id = branch.last_revision()
2552
elif len(revision) != 1:
2553
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2554
else:
2555
revision_id = revision[0].in_history(branch).rev_id
2556
file_id = tree.inventory.path2id(relpath)
2557
tree = branch.repository.revision_tree(revision_id)
2558
file_version = tree.inventory[file_id].revision
2559
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2560
finally:
2561
branch.unlock()
2562
2563
2564
class cmd_re_sign(Command):
2565
"""Create a digital signature for an existing revision."""
2566
# TODO be able to replace existing ones.
2567
2568
hidden = True # is this right ?
2569
takes_args = ['revision_id*']
2570
takes_options = ['revision']
2571
2572
def run(self, revision_id_list=None, revision=None):
2573
import bzrlib.gpg as gpg
2574
if revision_id_list is not None and revision is not None:
2575
raise BzrCommandError('You can only supply one of revision_id or --revision')
2576
if revision_id_list is None and revision is None:
2577
raise BzrCommandError('You must supply either --revision or a revision_id')
2578
b = WorkingTree.open_containing(u'.')[0].branch
2579
gpg_strategy = gpg.GPGStrategy(b.get_config())
2580
if revision_id_list is not None:
2581
for revision_id in revision_id_list:
2582
b.repository.sign_revision(revision_id, gpg_strategy)
2583
elif revision is not None:
2584
if len(revision) == 1:
2585
revno, rev_id = revision[0].in_history(b)
2586
b.repository.sign_revision(rev_id, gpg_strategy)
2587
elif len(revision) == 2:
2588
# are they both on rh- if so we can walk between them
2589
# might be nice to have a range helper for arbitrary
2590
# revision paths. hmm.
2591
from_revno, from_revid = revision[0].in_history(b)
2592
to_revno, to_revid = revision[1].in_history(b)
2593
if to_revid is None:
2594
to_revno = b.revno()
2595
if from_revno is None or to_revno is None:
2596
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2597
for revno in range(from_revno, to_revno + 1):
2598
b.repository.sign_revision(b.get_rev_id(revno),
2599
gpg_strategy)
2600
else:
2601
raise BzrCommandError('Please supply either one revision, or a range.')
2602
2603
2604
class cmd_bind(Command):
2605
"""Bind the current branch to a master branch.
2606
2607
After binding, commits must succeed on the master branch
2608
before they are executed on the local one.
2609
"""
2610
2611
takes_args = ['location']
2612
takes_options = []
2613
2614
def run(self, location=None):
2615
b, relpath = Branch.open_containing(u'.')
2616
b_other = Branch.open(location)
2617
try:
2618
b.bind(b_other)
2619
except DivergedBranches:
2620
raise BzrCommandError('These branches have diverged.'
2621
' Try merging, and then bind again.')
2622
2623
2624
class cmd_unbind(Command):
2625
"""Unbind the current branch from its master branch.
2626
2627
After unbinding, the local branch is considered independent.
2628
All subsequent commits will be local.
2629
"""
2630
2631
takes_args = []
2632
takes_options = []
2633
2634
def run(self):
2635
b, relpath = Branch.open_containing(u'.')
2636
if not b.unbind():
2637
raise BzrCommandError('Local branch is not bound')
2638
2639
2640
class cmd_uncommit(Command):
2641
"""Remove the last committed revision.
2642
2643
--verbose will print out what is being removed.
2644
--dry-run will go through all the motions, but not actually
2645
remove anything.
2646
2647
In the future, uncommit will create a revision bundle, which can then
2648
be re-applied.
2649
"""
2650
2651
# TODO: jam 20060108 Add an option to allow uncommit to remove
2652
# unreferenced information in 'branch-as-repository' branches.
2653
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2654
# information in shared branches as well.
2655
takes_options = ['verbose', 'revision',
2656
Option('dry-run', help='Don\'t actually make changes'),
2657
Option('force', help='Say yes to all questions.')]
2658
takes_args = ['location?']
2659
aliases = []
2660
2661
def run(self, location=None,
2662
dry_run=False, verbose=False,
2663
revision=None, force=False):
2664
from bzrlib.log import log_formatter, show_log
2665
import sys
2666
from bzrlib.uncommit import uncommit
2667
2668
if location is None:
2669
location = u'.'
2670
control, relpath = bzrdir.BzrDir.open_containing(location)
2671
try:
2672
tree = control.open_workingtree()
2673
b = tree.branch
2674
except (errors.NoWorkingTree, errors.NotLocalUrl):
2675
tree = None
2676
b = control.open_branch()
2677
2678
rev_id = None
2679
if revision is None:
2680
revno = b.revno()
2681
else:
2682
# 'bzr uncommit -r 10' actually means uncommit
2683
# so that the final tree is at revno 10.
2684
# but bzrlib.uncommit.uncommit() actually uncommits
2685
# the revisions that are supplied.
2686
# So we need to offset it by one
2687
revno = revision[0].in_history(b).revno+1
2688
2689
if revno <= b.revno():
2690
rev_id = b.get_rev_id(revno)
2691
if rev_id is None:
2692
self.outf.write('No revisions to uncommit.\n')
2693
return 1
2694
2695
lf = log_formatter('short',
2696
to_file=self.outf,
2697
show_timezone='original')
2698
2699
show_log(b,
2700
lf,
2701
verbose=False,
2702
direction='forward',
2703
start_revision=revno,
2704
end_revision=b.revno())
2705
2706
if dry_run:
2707
print 'Dry-run, pretending to remove the above revisions.'
2708
if not force:
2709
val = raw_input('Press <enter> to continue')
2710
else:
2711
print 'The above revision(s) will be removed.'
2712
if not force:
2713
val = raw_input('Are you sure [y/N]? ')
2714
if val.lower() not in ('y', 'yes'):
2715
print 'Canceled'
2716
return 0
2717
2718
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2719
revno=revno)
2720
2721
2722
class cmd_break_lock(Command):
2723
"""Break a dead lock on a repository, branch or working directory.
2724
2725
CAUTION: Locks should only be broken when you are sure that the process
2726
holding the lock has been stopped.
2727
2728
You can get information on what locks are open via the 'bzr info' command.
2729
2730
example:
2731
bzr break-lock
2732
"""
2733
takes_args = ['location?']
2734
2735
def run(self, location=None, show=False):
2736
if location is None:
2737
location = u'.'
2738
control, relpath = bzrdir.BzrDir.open_containing(location)
2739
try:
2740
control.break_lock()
2741
except NotImplementedError:
2742
pass
2743
2744
2745
2746
# command-line interpretation helper for merge-related commands
2747
def _merge_helper(other_revision, base_revision,
2748
check_clean=True, ignore_zero=False,
2749
this_dir=None, backup_files=False,
2750
merge_type=_mod_merge.Merge3Merger,
2751
file_list=None, show_base=False, reprocess=False,
2752
pb=DummyProgress()):
2753
"""Merge changes into a tree.
2754
2755
base_revision
2756
list(path, revno) Base for three-way merge.
2757
If [None, None] then a base will be automatically determined.
2758
other_revision
2759
list(path, revno) Other revision for three-way merge.
2760
this_dir
2761
Directory to merge changes into; '.' by default.
2762
check_clean
2763
If true, this_dir must have no uncommitted changes before the
2764
merge begins.
2765
ignore_zero - If true, suppress the "zero conflicts" message when
2766
there are no conflicts; should be set when doing something we expect
2767
to complete perfectly.
2768
file_list - If supplied, merge only changes to selected files.
2769
2770
All available ancestors of other_revision and base_revision are
2771
automatically pulled into the branch.
2772
2773
The revno may be -1 to indicate the last revision on the branch, which is
2774
the typical case.
2775
2776
This function is intended for use from the command line; programmatic
2777
clients might prefer to call merge.merge_inner(), which has less magic
2778
behavior.
2779
"""
2780
if this_dir is None:
2781
this_dir = u'.'
2782
this_tree = WorkingTree.open_containing(this_dir)[0]
2783
if show_base and not merge_type is _mod_merge.Merge3Merger:
2784
raise BzrCommandError("Show-base is not supported for this merge"
2785
" type. %s" % merge_type)
2786
if reprocess and not merge_type.supports_reprocess:
2787
raise BzrCommandError("Conflict reduction is not supported for merge"
2788
" type %s." % merge_type)
2789
if reprocess and show_base:
2790
raise BzrCommandError("Cannot do conflict reduction and show base.")
2791
try:
2792
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
2793
pb=pb)
2794
merger.pp = ProgressPhase("Merge phase", 5, pb)
2795
merger.pp.next_phase()
2796
merger.check_basis(check_clean)
2797
merger.set_other(other_revision)
2798
merger.pp.next_phase()
2799
merger.set_base(base_revision)
2800
if merger.base_rev_id == merger.other_rev_id:
2801
note('Nothing to do.')
2802
return 0
2803
merger.backup_files = backup_files
2804
merger.merge_type = merge_type
2805
merger.set_interesting_files(file_list)
2806
merger.show_base = show_base
2807
merger.reprocess = reprocess
2808
conflicts = merger.do_merge()
2809
if file_list is None:
2810
merger.set_pending()
2811
finally:
2812
pb.clear()
2813
return conflicts
2814
2815
2816
# Compatibility
2817
merge = _merge_helper
2818
2819
2820
# these get imported and then picked up by the scan for cmd_*
2821
# TODO: Some more consistent way to split command definitions across files;
2822
# we do need to load at least some information about them to know of
2823
# aliases. ideally we would avoid loading the implementation until the
2824
# details were needed.
2825
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2826
from bzrlib.bundle.commands import cmd_bundle_revisions
2827
from bzrlib.sign_my_commits import cmd_sign_my_commits
2828
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2829
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0