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