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