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