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