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