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