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