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