To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1857
- compare with another revision
- download diff
- download tarball
- view history from revision 1857
- Committer: Canonical.com Patch Queue Manager
- Date: 2006-07-12 12:36:57 UTC
- mfrom: (1732.3.4 bzr.revnoX)
- Revision ID: pqm@pqm.ubuntu.com-20060712123657-365eeb32b69308bf
(matthieu) revno:x:url revision spec
- files added:
- .bzrignore
- bzrlib
- bzrlib/benchmarks
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/plugins/launchpad
- bzrlib/store
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- doc
- tools
- tools/doc_generate
- files removed:
- .bzrignore
- notes
- tests
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
2
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
12
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
"""builtin bzr commands"""
18
19
20
import codecs
21
import errno
22
import os
23
import os.path
24
import sys
25
26
import bzrlib
27
from bzrlib.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 working tree.
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
bzr diff -r1
1092
bzr diff -r1..2
1093
bzr diff --diff-prefix old/:new/
1094
bzr diff bzr.mine bzr.dev
1095
bzr diff foo.c
1096
"""
1097
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1098
# or a graphical diff.
1099
1100
# TODO: Python difflib is not exactly the same as unidiff; should
1101
# either fix it up or prefer to use an external diff.
1102
1103
# TODO: Selected-file diff is inefficient and doesn't show you
1104
# deleted files.
1105
1106
# TODO: This probably handles non-Unix newlines poorly.
1107
1108
takes_args = ['file*']
1109
takes_options = ['revision', 'diff-options', 'prefix']
1110
aliases = ['di', 'dif']
1111
encoding_type = 'exact'
1112
1113
@display_command
1114
def run(self, revision=None, file_list=None, diff_options=None,
1115
prefix=None):
1116
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1117
1118
if (prefix is None) or (prefix == '0'):
1119
# diff -p0 format
1120
old_label = ''
1121
new_label = ''
1122
elif prefix == '1':
1123
old_label = 'old/'
1124
new_label = 'new/'
1125
else:
1126
if not ':' in prefix:
1127
raise BzrError("--diff-prefix expects two values separated by a colon")
1128
old_label, new_label = prefix.split(":")
1129
1130
try:
1131
tree1, file_list = internal_tree_files(file_list)
1132
tree2 = None
1133
b = None
1134
b2 = None
1135
except FileInWrongBranch:
1136
if len(file_list) != 2:
1137
raise BzrCommandError("Files are in different branches")
1138
1139
tree1, file1 = WorkingTree.open_containing(file_list[0])
1140
tree2, file2 = WorkingTree.open_containing(file_list[1])
1141
if file1 != "" or file2 != "":
1142
# FIXME diff those two files. rbc 20051123
1143
raise BzrCommandError("Files are in different branches")
1144
file_list = None
1145
except NotBranchError:
1146
# Don't raise an error when bzr diff is called from
1147
# outside a working tree.
1148
tree1, tree2 = None, None
1149
if revision is not None:
1150
if tree2 is not None:
1151
raise BzrCommandError("Can't specify -r with two branches")
1152
if (len(revision) == 1) or (revision[1].spec is None):
1153
return diff_cmd_helper(tree1, file_list, diff_options,
1154
revision[0],
1155
old_label=old_label, new_label=new_label)
1156
elif len(revision) == 2:
1157
return diff_cmd_helper(tree1, file_list, diff_options,
1158
revision[0], revision[1],
1159
old_label=old_label, new_label=new_label)
1160
else:
1161
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1162
else:
1163
if tree2 is not None:
1164
return show_diff_trees(tree1, tree2, sys.stdout,
1165
specific_files=file_list,
1166
external_diff_options=diff_options,
1167
old_label=old_label, new_label=new_label)
1168
else:
1169
return diff_cmd_helper(tree1, file_list, diff_options,
1170
old_label=old_label, new_label=new_label)
1171
1172
1173
class cmd_deleted(Command):
1174
"""List files deleted in the working tree.
1175
"""
1176
# TODO: Show files deleted since a previous revision, or
1177
# between two revisions.
1178
# TODO: Much more efficient way to do this: read in new
1179
# directories with readdir, rather than stating each one. Same
1180
# level of effort but possibly much less IO. (Or possibly not,
1181
# if the directories are very large...)
1182
takes_options = ['show-ids']
1183
1184
@display_command
1185
def run(self, show_ids=False):
1186
tree = WorkingTree.open_containing(u'.')[0]
1187
old = tree.basis_tree()
1188
for path, ie in old.inventory.iter_entries():
1189
if not tree.has_id(ie.file_id):
1190
self.outf.write(path)
1191
if show_ids:
1192
self.outf.write(' ')
1193
self.outf.write(ie.file_id)
1194
self.outf.write('\n')
1195
1196
1197
class cmd_modified(Command):
1198
"""List files modified in working tree."""
1199
hidden = True
1200
@display_command
1201
def run(self):
1202
from bzrlib.delta import compare_trees
1203
1204
tree = WorkingTree.open_containing(u'.')[0]
1205
td = compare_trees(tree.basis_tree(), tree)
1206
1207
for path, id, kind, text_modified, meta_modified in td.modified:
1208
self.outf.write(path + '\n')
1209
1210
1211
class cmd_added(Command):
1212
"""List files added in working tree."""
1213
hidden = True
1214
@display_command
1215
def run(self):
1216
wt = WorkingTree.open_containing(u'.')[0]
1217
basis_inv = wt.basis_tree().inventory
1218
inv = wt.inventory
1219
for file_id in inv:
1220
if file_id in basis_inv:
1221
continue
1222
path = inv.id2path(file_id)
1223
if not os.access(osutils.abspath(path), os.F_OK):
1224
continue
1225
self.outf.write(path + '\n')
1226
1227
1228
class cmd_root(Command):
1229
"""Show the tree root directory.
1230
1231
The root is the nearest enclosing directory with a .bzr control
1232
directory."""
1233
takes_args = ['filename?']
1234
@display_command
1235
def run(self, filename=None):
1236
"""Print the branch root."""
1237
tree = WorkingTree.open_containing(filename)[0]
1238
self.outf.write(tree.basedir + '\n')
1239
1240
1241
class cmd_log(Command):
1242
"""Show log of a branch, file, or directory.
1243
1244
By default show the log of the branch containing the working directory.
1245
1246
To request a range of logs, you can use the command -r begin..end
1247
-r revision requests a specific revision, -r ..end or -r begin.. are
1248
also valid.
1249
1250
examples:
1251
bzr log
1252
bzr log foo.c
1253
bzr log -r -10.. http://server/branch
1254
"""
1255
1256
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1257
1258
takes_args = ['location?']
1259
takes_options = [Option('forward',
1260
help='show from oldest to newest'),
1261
'timezone',
1262
Option('verbose',
1263
help='show files changed in each revision'),
1264
'show-ids', 'revision',
1265
'log-format',
1266
'line', 'long',
1267
Option('message',
1268
help='show revisions whose message matches this regexp',
1269
type=str),
1270
'short',
1271
]
1272
encoding_type = 'replace'
1273
1274
@display_command
1275
def run(self, location=None, timezone='original',
1276
verbose=False,
1277
show_ids=False,
1278
forward=False,
1279
revision=None,
1280
log_format=None,
1281
message=None,
1282
long=False,
1283
short=False,
1284
line=False):
1285
from bzrlib.log import log_formatter, show_log
1286
assert message is None or isinstance(message, basestring), \
1287
"invalid message argument %r" % message
1288
direction = (forward and 'forward') or 'reverse'
1289
1290
# log everything
1291
file_id = None
1292
if location:
1293
# find the file id to log:
1294
1295
dir, fp = bzrdir.BzrDir.open_containing(location)
1296
b = dir.open_branch()
1297
if fp != '':
1298
try:
1299
# might be a tree:
1300
inv = dir.open_workingtree().inventory
1301
except (errors.NotBranchError, errors.NotLocalUrl):
1302
# either no tree, or is remote.
1303
inv = b.basis_tree().inventory
1304
file_id = inv.path2id(fp)
1305
else:
1306
# local dir only
1307
# FIXME ? log the current subdir only RBC 20060203
1308
dir, relpath = bzrdir.BzrDir.open_containing('.')
1309
b = dir.open_branch()
1310
1311
if revision is None:
1312
rev1 = None
1313
rev2 = None
1314
elif len(revision) == 1:
1315
rev1 = rev2 = revision[0].in_history(b).revno
1316
elif len(revision) == 2:
1317
if revision[0].spec is None:
1318
# missing begin-range means first revision
1319
rev1 = 1
1320
else:
1321
rev1 = revision[0].in_history(b).revno
1322
1323
if revision[1].spec is None:
1324
# missing end-range means last known revision
1325
rev2 = b.revno()
1326
else:
1327
rev2 = revision[1].in_history(b).revno
1328
else:
1329
raise BzrCommandError('bzr log --revision takes one or two values.')
1330
1331
# By this point, the revision numbers are converted to the +ve
1332
# form if they were supplied in the -ve form, so we can do
1333
# this comparison in relative safety
1334
if rev1 > rev2:
1335
(rev2, rev1) = (rev1, rev2)
1336
1337
if (log_format == None):
1338
default = b.get_config().log_format()
1339
log_format = get_log_format(long=long, short=short, line=line,
1340
default=default)
1341
lf = log_formatter(log_format,
1342
show_ids=show_ids,
1343
to_file=self.outf,
1344
show_timezone=timezone)
1345
1346
show_log(b,
1347
lf,
1348
file_id,
1349
verbose=verbose,
1350
direction=direction,
1351
start_revision=rev1,
1352
end_revision=rev2,
1353
search=message)
1354
1355
1356
def get_log_format(long=False, short=False, line=False, default='long'):
1357
log_format = default
1358
if long:
1359
log_format = 'long'
1360
if short:
1361
log_format = 'short'
1362
if line:
1363
log_format = 'line'
1364
return log_format
1365
1366
1367
class cmd_touching_revisions(Command):
1368
"""Return revision-ids which affected a particular file.
1369
1370
A more user-friendly interface is "bzr log FILE".
1371
"""
1372
1373
hidden = True
1374
takes_args = ["filename"]
1375
1376
@display_command
1377
def run(self, filename):
1378
tree, relpath = WorkingTree.open_containing(filename)
1379
b = tree.branch
1380
inv = tree.read_working_inventory()
1381
file_id = inv.path2id(relpath)
1382
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1383
self.outf.write("%6d %s\n" % (revno, what))
1384
1385
1386
class cmd_ls(Command):
1387
"""List files in a tree.
1388
"""
1389
# TODO: Take a revision or remote path and list that tree instead.
1390
hidden = True
1391
takes_options = ['verbose', 'revision',
1392
Option('non-recursive',
1393
help='don\'t recurse into sub-directories'),
1394
Option('from-root',
1395
help='Print all paths from the root of the branch.'),
1396
Option('unknown', help='Print unknown files'),
1397
Option('versioned', help='Print versioned files'),
1398
Option('ignored', help='Print ignored files'),
1399
1400
Option('null', help='Null separate the files'),
1401
]
1402
@display_command
1403
def run(self, revision=None, verbose=False,
1404
non_recursive=False, from_root=False,
1405
unknown=False, versioned=False, ignored=False,
1406
null=False):
1407
1408
if verbose and null:
1409
raise BzrCommandError('Cannot set both --verbose and --null')
1410
all = not (unknown or versioned or ignored)
1411
1412
selection = {'I':ignored, '?':unknown, 'V':versioned}
1413
1414
tree, relpath = WorkingTree.open_containing(u'.')
1415
if from_root:
1416
relpath = u''
1417
elif relpath:
1418
relpath += '/'
1419
if revision is not None:
1420
tree = tree.branch.repository.revision_tree(
1421
revision[0].in_history(tree.branch).rev_id)
1422
1423
for fp, fc, kind, fid, entry in tree.list_files():
1424
if fp.startswith(relpath):
1425
fp = fp[len(relpath):]
1426
if non_recursive and '/' in fp:
1427
continue
1428
if not all and not selection[fc]:
1429
continue
1430
if verbose:
1431
kindch = entry.kind_character()
1432
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1433
elif null:
1434
self.outf.write(fp + '\0')
1435
self.outf.flush()
1436
else:
1437
self.outf.write(fp + '\n')
1438
1439
1440
class cmd_unknowns(Command):
1441
"""List unknown files."""
1442
@display_command
1443
def run(self):
1444
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1445
self.outf.write(osutils.quotefn(f) + '\n')
1446
1447
1448
class cmd_ignore(Command):
1449
"""Ignore a command or pattern.
1450
1451
To remove patterns from the ignore list, edit the .bzrignore file.
1452
1453
If the pattern contains a slash, it is compared to the whole path
1454
from the branch root. Otherwise, it is compared to only the last
1455
component of the path. To match a file only in the root directory,
1456
prepend './'.
1457
1458
Ignore patterns are case-insensitive on case-insensitive systems.
1459
1460
Note: wildcards must be quoted from the shell on Unix.
1461
1462
examples:
1463
bzr ignore ./Makefile
1464
bzr ignore '*.class'
1465
"""
1466
# TODO: Complain if the filename is absolute
1467
takes_args = ['name_pattern?']
1468
takes_options = [
1469
Option('old-default-rules',
1470
help='Out the ignore rules bzr < 0.9 always used.')
1471
]
1472
1473
def run(self, name_pattern=None, old_default_rules=None):
1474
from bzrlib.atomicfile import AtomicFile
1475
if old_default_rules is not None:
1476
# dump the rules and exit
1477
for pattern in bzrlib.DEFAULT_IGNORE:
1478
print pattern
1479
return
1480
if name_pattern is None:
1481
raise BzrCommandError("ignore requires a NAME_PATTERN")
1482
tree, relpath = WorkingTree.open_containing(u'.')
1483
ifn = tree.abspath('.bzrignore')
1484
if os.path.exists(ifn):
1485
f = open(ifn, 'rt')
1486
try:
1487
igns = f.read().decode('utf-8')
1488
finally:
1489
f.close()
1490
else:
1491
igns = ''
1492
1493
# TODO: If the file already uses crlf-style termination, maybe
1494
# we should use that for the newly added lines?
1495
1496
if igns and igns[-1] != '\n':
1497
igns += '\n'
1498
igns += name_pattern + '\n'
1499
1500
f = AtomicFile(ifn, 'wt')
1501
try:
1502
f.write(igns.encode('utf-8'))
1503
f.commit()
1504
finally:
1505
f.close()
1506
1507
inv = tree.inventory
1508
if inv.path2id('.bzrignore'):
1509
mutter('.bzrignore is already versioned')
1510
else:
1511
mutter('need to make new .bzrignore file versioned')
1512
tree.add(['.bzrignore'])
1513
1514
1515
class cmd_ignored(Command):
1516
"""List ignored files and the patterns that matched them.
1517
1518
See also: bzr ignore"""
1519
@display_command
1520
def run(self):
1521
tree = WorkingTree.open_containing(u'.')[0]
1522
for path, file_class, kind, file_id, entry in tree.list_files():
1523
if file_class != 'I':
1524
continue
1525
## XXX: Slightly inefficient since this was already calculated
1526
pat = tree.is_ignored(path)
1527
print '%-50s %s' % (path, pat)
1528
1529
1530
class cmd_lookup_revision(Command):
1531
"""Lookup the revision-id from a revision-number
1532
1533
example:
1534
bzr lookup-revision 33
1535
"""
1536
hidden = True
1537
takes_args = ['revno']
1538
1539
@display_command
1540
def run(self, revno):
1541
try:
1542
revno = int(revno)
1543
except ValueError:
1544
raise BzrCommandError("not a valid revision-number: %r" % revno)
1545
1546
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1547
1548
1549
class cmd_export(Command):
1550
"""Export past revision to destination directory.
1551
1552
If no revision is specified this exports the last committed revision.
1553
1554
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1555
given, try to find the format with the extension. If no extension
1556
is found exports to a directory (equivalent to --format=dir).
1557
1558
Root may be the top directory for tar, tgz and tbz2 formats. If none
1559
is given, the top directory will be the root name of the file.
1560
1561
Note: export of tree with non-ascii filenames to zip is not supported.
1562
1563
Supported formats Autodetected by extension
1564
----------------- -------------------------
1565
dir -
1566
tar .tar
1567
tbz2 .tar.bz2, .tbz2
1568
tgz .tar.gz, .tgz
1569
zip .zip
1570
"""
1571
takes_args = ['dest']
1572
takes_options = ['revision', 'format', 'root']
1573
def run(self, dest, revision=None, format=None, root=None):
1574
from bzrlib.export import export
1575
tree = WorkingTree.open_containing(u'.')[0]
1576
b = tree.branch
1577
if revision is None:
1578
# should be tree.last_revision FIXME
1579
rev_id = b.last_revision()
1580
else:
1581
if len(revision) != 1:
1582
raise BzrError('bzr export --revision takes exactly 1 argument')
1583
rev_id = revision[0].in_history(b).rev_id
1584
t = b.repository.revision_tree(rev_id)
1585
try:
1586
export(t, dest, format, root)
1587
except errors.NoSuchExportFormat, e:
1588
raise BzrCommandError('Unsupported export format: %s' % e.format)
1589
1590
1591
class cmd_cat(Command):
1592
"""Write a file's text from a previous revision."""
1593
1594
takes_options = ['revision']
1595
takes_args = ['filename']
1596
1597
@display_command
1598
def run(self, filename, revision=None):
1599
if revision is not None and len(revision) != 1:
1600
raise BzrCommandError("bzr cat --revision takes exactly one number")
1601
tree = None
1602
try:
1603
tree, relpath = WorkingTree.open_containing(filename)
1604
b = tree.branch
1605
except NotBranchError:
1606
pass
1607
1608
if tree is None:
1609
b, relpath = Branch.open_containing(filename)
1610
if revision is None:
1611
revision_id = b.last_revision()
1612
else:
1613
revision_id = revision[0].in_history(b).rev_id
1614
b.print_file(relpath, revision_id)
1615
1616
1617
class cmd_local_time_offset(Command):
1618
"""Show the offset in seconds from GMT to local time."""
1619
hidden = True
1620
@display_command
1621
def run(self):
1622
print osutils.local_time_offset()
1623
1624
1625
1626
class cmd_commit(Command):
1627
"""Commit changes into a new revision.
1628
1629
If no arguments are given, the entire tree is committed.
1630
1631
If selected files are specified, only changes to those files are
1632
committed. If a directory is specified then the directory and everything
1633
within it is committed.
1634
1635
A selected-file commit may fail in some cases where the committed
1636
tree would be invalid, such as trying to commit a file in a
1637
newly-added directory that is not itself committed.
1638
"""
1639
# TODO: Run hooks on tree to-be-committed, and after commit.
1640
1641
# TODO: Strict commit that fails if there are deleted files.
1642
# (what does "deleted files" mean ??)
1643
1644
# TODO: Give better message for -s, --summary, used by tla people
1645
1646
# XXX: verbose currently does nothing
1647
1648
takes_args = ['selected*']
1649
takes_options = ['message', 'verbose',
1650
Option('unchanged',
1651
help='commit even if nothing has changed'),
1652
Option('file', type=str,
1653
argname='msgfile',
1654
help='file containing commit message'),
1655
Option('strict',
1656
help="refuse to commit if there are unknown "
1657
"files in the working tree."),
1658
Option('local',
1659
help="perform a local only commit in a bound "
1660
"branch. Such commits are not pushed to "
1661
"the master branch until a normal commit "
1662
"is performed."
1663
),
1664
]
1665
aliases = ['ci', 'checkin']
1666
1667
def run(self, message=None, file=None, verbose=True, selected_list=None,
1668
unchanged=False, strict=False, local=False):
1669
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1670
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1671
StrictCommitFailed)
1672
from bzrlib.msgeditor import edit_commit_message, \
1673
make_commit_message_template
1674
from tempfile import TemporaryFile
1675
1676
# TODO: Need a blackbox test for invoking the external editor; may be
1677
# slightly problematic to run this cross-platform.
1678
1679
# TODO: do more checks that the commit will succeed before
1680
# spending the user's valuable time typing a commit message.
1681
#
1682
# TODO: if the commit *does* happen to fail, then save the commit
1683
# message to a temporary file where it can be recovered
1684
tree, selected_list = tree_files(selected_list)
1685
if selected_list == ['']:
1686
# workaround - commit of root of tree should be exactly the same
1687
# as just default commit in that tree, and succeed even though
1688
# selected-file merge commit is not done yet
1689
selected_list = []
1690
1691
if local and not tree.branch.get_bound_location():
1692
raise errors.LocalRequiresBoundBranch()
1693
if message is None and not file:
1694
template = make_commit_message_template(tree, selected_list)
1695
message = edit_commit_message(template)
1696
if message is None:
1697
raise BzrCommandError("please specify a commit message"
1698
" with either --message or --file")
1699
elif message and file:
1700
raise BzrCommandError("please specify either --message or --file")
1701
1702
if file:
1703
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1704
1705
if message == "":
1706
raise BzrCommandError("empty commit message specified")
1707
1708
if verbose:
1709
reporter = ReportCommitToLog()
1710
else:
1711
reporter = NullCommitReporter()
1712
1713
try:
1714
tree.commit(message, specific_files=selected_list,
1715
allow_pointless=unchanged, strict=strict, local=local,
1716
reporter=reporter)
1717
except PointlessCommit:
1718
# FIXME: This should really happen before the file is read in;
1719
# perhaps prepare the commit; get the message; then actually commit
1720
raise BzrCommandError("no changes to commit."
1721
" use --unchanged to commit anyhow")
1722
except ConflictsInTree:
1723
raise BzrCommandError("Conflicts detected in working tree. "
1724
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1725
except StrictCommitFailed:
1726
raise BzrCommandError("Commit refused because there are unknown "
1727
"files in the working tree.")
1728
except errors.BoundBranchOutOfDate, e:
1729
raise BzrCommandError(str(e)
1730
+ ' Either unbind, update, or'
1731
' pass --local to commit.')
1732
1733
1734
class cmd_check(Command):
1735
"""Validate consistency of branch history.
1736
1737
This command checks various invariants about the branch storage to
1738
detect data corruption or bzr bugs.
1739
"""
1740
takes_args = ['branch?']
1741
takes_options = ['verbose']
1742
1743
def run(self, branch=None, verbose=False):
1744
from bzrlib.check import check
1745
if branch is None:
1746
tree = WorkingTree.open_containing()[0]
1747
branch = tree.branch
1748
else:
1749
branch = Branch.open(branch)
1750
check(branch, verbose)
1751
1752
1753
class cmd_scan_cache(Command):
1754
hidden = True
1755
def run(self):
1756
from bzrlib.hashcache import HashCache
1757
1758
c = HashCache(u'.')
1759
c.read()
1760
c.scan()
1761
1762
print '%6d stats' % c.stat_count
1763
print '%6d in hashcache' % len(c._cache)
1764
print '%6d files removed from cache' % c.removed_count
1765
print '%6d hashes updated' % c.update_count
1766
print '%6d files changed too recently to cache' % c.danger_count
1767
1768
if c.needs_write:
1769
c.write()
1770
1771
1772
class cmd_upgrade(Command):
1773
"""Upgrade branch storage to current format.
1774
1775
The check command or bzr developers may sometimes advise you to run
1776
this command. When the default format has changed you may also be warned
1777
during other operations to upgrade.
1778
"""
1779
takes_args = ['url?']
1780
takes_options = [
1781
Option('format',
1782
help='Upgrade to a specific format. Current formats'
1783
' are: default, knit, metaweave and weave.'
1784
' Default is knit; metaweave and weave are'
1785
' deprecated',
1786
type=get_format_type),
1787
]
1788
1789
1790
def run(self, url='.', format=None):
1791
from bzrlib.upgrade import upgrade
1792
if format is None:
1793
format = get_format_type('default')
1794
upgrade(url, format)
1795
1796
1797
class cmd_whoami(Command):
1798
"""Show or set bzr user id.
1799
1800
examples:
1801
bzr whoami --email
1802
bzr whoami 'Frank Chu <fchu@example.com>'
1803
"""
1804
takes_options = [ Option('email',
1805
help='display email address only'),
1806
Option('branch',
1807
help='set identity for the current branch instead of '
1808
'globally'),
1809
]
1810
takes_args = ['name?']
1811
encoding_type = 'replace'
1812
1813
@display_command
1814
def run(self, email=False, branch=False, name=None):
1815
if name is None:
1816
# use branch if we're inside one; otherwise global config
1817
try:
1818
c = Branch.open_containing('.')[0].get_config()
1819
except NotBranchError:
1820
c = config.GlobalConfig()
1821
if email:
1822
self.outf.write(c.user_email() + '\n')
1823
else:
1824
self.outf.write(c.username() + '\n')
1825
return
1826
1827
# use global config unless --branch given
1828
if branch:
1829
c = Branch.open_containing('.')[0].get_config()
1830
else:
1831
c = config.GlobalConfig()
1832
c.set_user_option('email', name)
1833
1834
1835
class cmd_nick(Command):
1836
"""Print or set the branch nickname.
1837
1838
If unset, the tree root directory name is used as the nickname
1839
To print the current nickname, execute with no argument.
1840
"""
1841
takes_args = ['nickname?']
1842
def run(self, nickname=None):
1843
branch = Branch.open_containing(u'.')[0]
1844
if nickname is None:
1845
self.printme(branch)
1846
else:
1847
branch.nick = nickname
1848
1849
@display_command
1850
def printme(self, branch):
1851
print branch.nick
1852
1853
1854
class cmd_selftest(Command):
1855
"""Run internal test suite.
1856
1857
This creates temporary test directories in the working directory,
1858
but not existing data is affected. These directories are deleted
1859
if the tests pass, or left behind to help in debugging if they
1860
fail and --keep-output is specified.
1861
1862
If arguments are given, they are regular expressions that say
1863
which tests should run.
1864
1865
If the global option '--no-plugins' is given, plugins are not loaded
1866
before running the selftests. This has two effects: features provided or
1867
modified by plugins will not be tested, and tests provided by plugins will
1868
not be run.
1869
1870
examples:
1871
bzr selftest ignore
1872
bzr --no-plugins selftest -v
1873
"""
1874
# TODO: --list should give a list of all available tests
1875
1876
# NB: this is used from the class without creating an instance, which is
1877
# why it does not have a self parameter.
1878
def get_transport_type(typestring):
1879
"""Parse and return a transport specifier."""
1880
if typestring == "sftp":
1881
from bzrlib.transport.sftp import SFTPAbsoluteServer
1882
return SFTPAbsoluteServer
1883
if typestring == "memory":
1884
from bzrlib.transport.memory import MemoryServer
1885
return MemoryServer
1886
if typestring == "fakenfs":
1887
from bzrlib.transport.fakenfs import FakeNFSServer
1888
return FakeNFSServer
1889
msg = "No known transport type %s. Supported types are: sftp\n" %\
1890
(typestring)
1891
raise BzrCommandError(msg)
1892
1893
hidden = True
1894
takes_args = ['testspecs*']
1895
takes_options = ['verbose',
1896
Option('one', help='stop when one test fails'),
1897
Option('keep-output',
1898
help='keep output directories when tests fail'),
1899
Option('transport',
1900
help='Use a different transport by default '
1901
'throughout the test suite.',
1902
type=get_transport_type),
1903
Option('benchmark', help='run the bzr bencharks.'),
1904
Option('lsprof-timed',
1905
help='generate lsprof output for benchmarked'
1906
' sections of code.'),
1907
]
1908
1909
def run(self, testspecs_list=None, verbose=None, one=False,
1910
keep_output=False, transport=None, benchmark=None,
1911
lsprof_timed=None):
1912
import bzrlib.ui
1913
from bzrlib.tests import selftest
1914
import bzrlib.benchmarks as benchmarks
1915
# we don't want progress meters from the tests to go to the
1916
# real output; and we don't want log messages cluttering up
1917
# the real logs.
1918
save_ui = ui.ui_factory
1919
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1920
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1921
print
1922
info('running tests...')
1923
try:
1924
ui.ui_factory = ui.SilentUIFactory()
1925
if testspecs_list is not None:
1926
pattern = '|'.join(testspecs_list)
1927
else:
1928
pattern = ".*"
1929
if benchmark:
1930
test_suite_factory = benchmarks.test_suite
1931
if verbose is None:
1932
verbose = True
1933
else:
1934
test_suite_factory = None
1935
if verbose is None:
1936
verbose = False
1937
result = selftest(verbose=verbose,
1938
pattern=pattern,
1939
stop_on_failure=one,
1940
keep_output=keep_output,
1941
transport=transport,
1942
test_suite_factory=test_suite_factory,
1943
lsprof_timed=lsprof_timed)
1944
if result:
1945
info('tests passed')
1946
else:
1947
info('tests failed')
1948
return int(not result)
1949
finally:
1950
ui.ui_factory = save_ui
1951
1952
1953
def _get_bzr_branch():
1954
"""If bzr is run from a branch, return Branch or None"""
1955
from os.path import dirname
1956
1957
try:
1958
branch = Branch.open(dirname(osutils.abspath(dirname(__file__))))
1959
return branch
1960
except errors.BzrError:
1961
return None
1962
1963
1964
def show_version():
1965
import bzrlib
1966
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1967
# is bzrlib itself in a branch?
1968
branch = _get_bzr_branch()
1969
if branch:
1970
rh = branch.revision_history()
1971
revno = len(rh)
1972
print " bzr checkout, revision %d" % (revno,)
1973
print " nick: %s" % (branch.nick,)
1974
if rh:
1975
print " revid: %s" % (rh[-1],)
1976
print "Using python interpreter:", sys.executable
1977
import site
1978
print "Using python standard library:", os.path.dirname(site.__file__)
1979
print "Using bzrlib:",
1980
if len(bzrlib.__path__) > 1:
1981
# print repr, which is a good enough way of making it clear it's
1982
# more than one element (eg ['/foo/bar', '/foo/bzr'])
1983
print repr(bzrlib.__path__)
1984
else:
1985
print bzrlib.__path__[0]
1986
1987
print
1988
print bzrlib.__copyright__
1989
print "http://bazaar-vcs.org/"
1990
print
1991
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1992
print "you may use, modify and redistribute it under the terms of the GNU"
1993
print "General Public License version 2 or later."
1994
1995
1996
class cmd_version(Command):
1997
"""Show version of bzr."""
1998
@display_command
1999
def run(self):
2000
show_version()
2001
2002
class cmd_rocks(Command):
2003
"""Statement of optimism."""
2004
hidden = True
2005
@display_command
2006
def run(self):
2007
print "it sure does!"
2008
2009
2010
class cmd_find_merge_base(Command):
2011
"""Find and print a base revision for merging two branches.
2012
"""
2013
# TODO: Options to specify revisions on either side, as if
2014
# merging only part of the history.
2015
takes_args = ['branch', 'other']
2016
hidden = True
2017
2018
@display_command
2019
def run(self, branch, other):
2020
from bzrlib.revision import common_ancestor, MultipleRevisionSources
2021
2022
branch1 = Branch.open_containing(branch)[0]
2023
branch2 = Branch.open_containing(other)[0]
2024
2025
history_1 = branch1.revision_history()
2026
history_2 = branch2.revision_history()
2027
2028
last1 = branch1.last_revision()
2029
last2 = branch2.last_revision()
2030
2031
source = MultipleRevisionSources(branch1.repository,
2032
branch2.repository)
2033
2034
base_rev_id = common_ancestor(last1, last2, source)
2035
2036
print 'merge base is revision %s' % base_rev_id
2037
2038
2039
class cmd_merge(Command):
2040
"""Perform a three-way merge.
2041
2042
The branch is the branch you will merge from. By default, it will merge
2043
the latest revision. If you specify a revision, that revision will be
2044
merged. If you specify two revisions, the first will be used as a BASE,
2045
and the second one as OTHER. Revision numbers are always relative to the
2046
specified branch.
2047
2048
By default, bzr will try to merge in all new work from the other
2049
branch, automatically determining an appropriate base. If this
2050
fails, you may need to give an explicit base.
2051
2052
Merge will do its best to combine the changes in two branches, but there
2053
are some kinds of problems only a human can fix. When it encounters those,
2054
it will mark a conflict. A conflict means that you need to fix something,
2055
before you should commit.
2056
2057
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2058
2059
If there is no default branch set, the first merge will set it. After
2060
that, you can omit the branch to use the default. To change the
2061
default, use --remember. The value will only be saved if the remote
2062
location can be accessed.
2063
2064
Examples:
2065
2066
To merge the latest revision from bzr.dev
2067
bzr merge ../bzr.dev
2068
2069
To merge changes up to and including revision 82 from bzr.dev
2070
bzr merge -r 82 ../bzr.dev
2071
2072
To merge the changes introduced by 82, without previous changes:
2073
bzr merge -r 81..82 ../bzr.dev
2074
2075
merge refuses to run if there are any uncommitted changes, unless
2076
--force is given.
2077
2078
The following merge types are available:
2079
"""
2080
takes_args = ['branch?']
2081
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2082
Option('show-base', help="Show base revision text in "
2083
"conflicts")]
2084
2085
def help(self):
2086
from merge import merge_type_help
2087
from inspect import getdoc
2088
return getdoc(self) + '\n' + merge_type_help()
2089
2090
def run(self, branch=None, revision=None, force=False, merge_type=None,
2091
show_base=False, reprocess=False, remember=False):
2092
if merge_type is None:
2093
merge_type = Merge3Merger
2094
2095
tree = WorkingTree.open_containing(u'.')[0]
2096
2097
if branch is not None:
2098
try:
2099
reader = bundle.read_bundle_from_url(branch)
2100
except NotABundle:
2101
pass # Continue on considering this url a Branch
2102
else:
2103
conflicts = merge_bundle(reader, tree, not force, merge_type,
2104
reprocess, show_base)
2105
if conflicts == 0:
2106
return 0
2107
else:
2108
return 1
2109
2110
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2111
2112
if revision is None or len(revision) < 1:
2113
base = [None, None]
2114
other = [branch, -1]
2115
other_branch, path = Branch.open_containing(branch)
2116
else:
2117
if len(revision) == 1:
2118
base = [None, None]
2119
other_branch, path = Branch.open_containing(branch)
2120
revno = revision[0].in_history(other_branch).revno
2121
other = [branch, revno]
2122
else:
2123
assert len(revision) == 2
2124
if None in revision:
2125
raise BzrCommandError(
2126
"Merge doesn't permit that revision specifier.")
2127
other_branch, path = Branch.open_containing(branch)
2128
2129
base = [branch, revision[0].in_history(other_branch).revno]
2130
other = [branch, revision[1].in_history(other_branch).revno]
2131
2132
if tree.branch.get_parent() is None or remember:
2133
tree.branch.set_parent(other_branch.base)
2134
2135
if path != "":
2136
interesting_files = [path]
2137
else:
2138
interesting_files = None
2139
pb = ui.ui_factory.nested_progress_bar()
2140
try:
2141
try:
2142
conflict_count = merge(other, base, check_clean=(not force),
2143
merge_type=merge_type,
2144
reprocess=reprocess,
2145
show_base=show_base,
2146
pb=pb, file_list=interesting_files)
2147
finally:
2148
pb.finished()
2149
if conflict_count != 0:
2150
return 1
2151
else:
2152
return 0
2153
except errors.AmbiguousBase, e:
2154
m = ("sorry, bzr can't determine the right merge base yet\n"
2155
"candidates are:\n "
2156
+ "\n ".join(e.bases)
2157
+ "\n"
2158
"please specify an explicit base with -r,\n"
2159
"and (if you want) report this to the bzr developers\n")
2160
log_error(m)
2161
2162
# TODO: move up to common parent; this isn't merge-specific anymore.
2163
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2164
"""Use tree.branch's parent if none was supplied.
2165
2166
Report if the remembered location was used.
2167
"""
2168
if supplied_location is not None:
2169
return supplied_location
2170
stored_location = tree.branch.get_parent()
2171
mutter("%s", stored_location)
2172
if stored_location is None:
2173
raise BzrCommandError("No location specified or remembered")
2174
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2175
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2176
return stored_location
2177
2178
2179
class cmd_remerge(Command):
2180
"""Redo a merge.
2181
2182
Use this if you want to try a different merge technique while resolving
2183
conflicts. Some merge techniques are better than others, and remerge
2184
lets you try different ones on different files.
2185
2186
The options for remerge have the same meaning and defaults as the ones for
2187
merge. The difference is that remerge can (only) be run when there is a
2188
pending merge, and it lets you specify particular files.
2189
2190
Examples:
2191
$ bzr remerge --show-base
2192
Re-do the merge of all conflicted files, and show the base text in
2193
conflict regions, in addition to the usual THIS and OTHER texts.
2194
2195
$ bzr remerge --merge-type weave --reprocess foobar
2196
Re-do the merge of "foobar", using the weave merge algorithm, with
2197
additional processing to reduce the size of conflict regions.
2198
2199
The following merge types are available:"""
2200
takes_args = ['file*']
2201
takes_options = ['merge-type', 'reprocess',
2202
Option('show-base', help="Show base revision text in "
2203
"conflicts")]
2204
2205
def help(self):
2206
from merge import merge_type_help
2207
from inspect import getdoc
2208
return getdoc(self) + '\n' + merge_type_help()
2209
2210
def run(self, file_list=None, merge_type=None, show_base=False,
2211
reprocess=False):
2212
from bzrlib.merge import merge_inner, transform_tree
2213
if merge_type is None:
2214
merge_type = Merge3Merger
2215
tree, file_list = tree_files(file_list)
2216
tree.lock_write()
2217
try:
2218
pending_merges = tree.pending_merges()
2219
if len(pending_merges) != 1:
2220
raise BzrCommandError("Sorry, remerge only works after normal"
2221
" merges. Not cherrypicking or"
2222
" multi-merges.")
2223
repository = tree.branch.repository
2224
base_revision = common_ancestor(tree.branch.last_revision(),
2225
pending_merges[0], repository)
2226
base_tree = repository.revision_tree(base_revision)
2227
other_tree = repository.revision_tree(pending_merges[0])
2228
interesting_ids = None
2229
new_conflicts = []
2230
conflicts = tree.conflicts()
2231
if file_list is not None:
2232
interesting_ids = set()
2233
for filename in file_list:
2234
file_id = tree.path2id(filename)
2235
if file_id is None:
2236
raise NotVersionedError(filename)
2237
interesting_ids.add(file_id)
2238
if tree.kind(file_id) != "directory":
2239
continue
2240
2241
for name, ie in tree.inventory.iter_entries(file_id):
2242
interesting_ids.add(ie.file_id)
2243
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2244
transform_tree(tree, tree.basis_tree(), interesting_ids)
2245
tree.set_conflicts(ConflictList(new_conflicts))
2246
if file_list is None:
2247
restore_files = list(tree.iter_conflicts())
2248
else:
2249
restore_files = file_list
2250
for filename in restore_files:
2251
try:
2252
restore(tree.abspath(filename))
2253
except NotConflicted:
2254
pass
2255
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2256
this_tree=tree,
2257
interesting_ids=interesting_ids,
2258
other_rev_id=pending_merges[0],
2259
merge_type=merge_type,
2260
show_base=show_base,
2261
reprocess=reprocess)
2262
finally:
2263
tree.unlock()
2264
if conflicts > 0:
2265
return 1
2266
else:
2267
return 0
2268
2269
class cmd_revert(Command):
2270
"""Reverse all changes since the last commit.
2271
2272
Only versioned files are affected. Specify filenames to revert only
2273
those files. By default, any files that are changed will be backed up
2274
first. Backup files have a '~' appended to their name.
2275
"""
2276
takes_options = ['revision', 'no-backup']
2277
takes_args = ['file*']
2278
aliases = ['merge-revert']
2279
2280
def run(self, revision=None, no_backup=False, file_list=None):
2281
from bzrlib.commands import parse_spec
2282
if file_list is not None:
2283
if len(file_list) == 0:
2284
raise BzrCommandError("No files specified")
2285
else:
2286
file_list = []
2287
2288
tree, file_list = tree_files(file_list)
2289
if revision is None:
2290
# FIXME should be tree.last_revision
2291
rev_id = tree.last_revision()
2292
elif len(revision) != 1:
2293
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2294
else:
2295
rev_id = revision[0].in_history(tree.branch).rev_id
2296
pb = ui.ui_factory.nested_progress_bar()
2297
try:
2298
tree.revert(file_list,
2299
tree.branch.repository.revision_tree(rev_id),
2300
not no_backup, pb)
2301
finally:
2302
pb.finished()
2303
2304
2305
class cmd_assert_fail(Command):
2306
"""Test reporting of assertion failures"""
2307
hidden = True
2308
def run(self):
2309
assert False, "always fails"
2310
2311
2312
class cmd_help(Command):
2313
"""Show help on a command or other topic.
2314
2315
For a list of all available commands, say 'bzr help commands'."""
2316
takes_options = [Option('long', 'show help on all commands')]
2317
takes_args = ['topic?']
2318
aliases = ['?', '--help', '-?', '-h']
2319
2320
@display_command
2321
def run(self, topic=None, long=False):
2322
import help
2323
if topic is None and long:
2324
topic = "commands"
2325
help.help(topic)
2326
2327
2328
class cmd_shell_complete(Command):
2329
"""Show appropriate completions for context.
2330
2331
For a list of all available commands, say 'bzr shell-complete'."""
2332
takes_args = ['context?']
2333
aliases = ['s-c']
2334
hidden = True
2335
2336
@display_command
2337
def run(self, context=None):
2338
import shellcomplete
2339
shellcomplete.shellcomplete(context)
2340
2341
2342
class cmd_fetch(Command):
2343
"""Copy in history from another branch but don't merge it.
2344
2345
This is an internal method used for pull and merge."""
2346
hidden = True
2347
takes_args = ['from_branch', 'to_branch']
2348
def run(self, from_branch, to_branch):
2349
from bzrlib.fetch import Fetcher
2350
from_b = Branch.open(from_branch)
2351
to_b = Branch.open(to_branch)
2352
Fetcher(to_b, from_b)
2353
2354
2355
class cmd_missing(Command):
2356
"""Show unmerged/unpulled revisions between two branches.
2357
2358
OTHER_BRANCH may be local or remote."""
2359
takes_args = ['other_branch?']
2360
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2361
Option('mine-only',
2362
'Display changes in the local branch only'),
2363
Option('theirs-only',
2364
'Display changes in the remote branch only'),
2365
'log-format',
2366
'line',
2367
'long',
2368
'short',
2369
'show-ids',
2370
'verbose'
2371
]
2372
encoding_type = 'replace'
2373
2374
@display_command
2375
def run(self, other_branch=None, reverse=False, mine_only=False,
2376
theirs_only=False, log_format=None, long=False, short=False, line=False,
2377
show_ids=False, verbose=False):
2378
from bzrlib.missing import find_unmerged, iter_log_data
2379
from bzrlib.log import log_formatter
2380
local_branch = Branch.open_containing(u".")[0]
2381
parent = local_branch.get_parent()
2382
if other_branch is None:
2383
other_branch = parent
2384
if other_branch is None:
2385
raise BzrCommandError("No missing location known or specified.")
2386
print "Using last location: " + local_branch.get_parent()
2387
remote_branch = Branch.open(other_branch)
2388
if remote_branch.base == local_branch.base:
2389
remote_branch = local_branch
2390
local_branch.lock_read()
2391
try:
2392
remote_branch.lock_read()
2393
try:
2394
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2395
if (log_format == None):
2396
default = local_branch.get_config().log_format()
2397
log_format = get_log_format(long=long, short=short,
2398
line=line, default=default)
2399
lf = log_formatter(log_format,
2400
to_file=self.outf,
2401
show_ids=show_ids,
2402
show_timezone='original')
2403
if reverse is False:
2404
local_extra.reverse()
2405
remote_extra.reverse()
2406
if local_extra and not theirs_only:
2407
print "You have %d extra revision(s):" % len(local_extra)
2408
for data in iter_log_data(local_extra, local_branch.repository,
2409
verbose):
2410
lf.show(*data)
2411
printed_local = True
2412
else:
2413
printed_local = False
2414
if remote_extra and not mine_only:
2415
if printed_local is True:
2416
print "\n\n"
2417
print "You are missing %d revision(s):" % len(remote_extra)
2418
for data in iter_log_data(remote_extra, remote_branch.repository,
2419
verbose):
2420
lf.show(*data)
2421
if not remote_extra and not local_extra:
2422
status_code = 0
2423
print "Branches are up to date."
2424
else:
2425
status_code = 1
2426
finally:
2427
remote_branch.unlock()
2428
finally:
2429
local_branch.unlock()
2430
if not status_code and parent is None and other_branch is not None:
2431
local_branch.lock_write()
2432
try:
2433
# handle race conditions - a parent might be set while we run.
2434
if local_branch.get_parent() is None:
2435
local_branch.set_parent(remote_branch.base)
2436
finally:
2437
local_branch.unlock()
2438
return status_code
2439
2440
2441
class cmd_plugins(Command):
2442
"""List plugins"""
2443
hidden = True
2444
@display_command
2445
def run(self):
2446
import bzrlib.plugin
2447
from inspect import getdoc
2448
for name, plugin in bzrlib.plugin.all_plugins().items():
2449
if hasattr(plugin, '__path__'):
2450
print plugin.__path__[0]
2451
elif hasattr(plugin, '__file__'):
2452
print plugin.__file__
2453
else:
2454
print `plugin`
2455
2456
d = getdoc(plugin)
2457
if d:
2458
print '\t', d.split('\n')[0]
2459
2460
2461
class cmd_testament(Command):
2462
"""Show testament (signing-form) of a revision."""
2463
takes_options = ['revision', 'long',
2464
Option('strict', help='Produce a strict-format'
2465
' testament')]
2466
takes_args = ['branch?']
2467
@display_command
2468
def run(self, branch=u'.', revision=None, long=False, strict=False):
2469
from bzrlib.testament import Testament, StrictTestament
2470
if strict is True:
2471
testament_class = StrictTestament
2472
else:
2473
testament_class = Testament
2474
b = WorkingTree.open_containing(branch)[0].branch
2475
b.lock_read()
2476
try:
2477
if revision is None:
2478
rev_id = b.last_revision()
2479
else:
2480
rev_id = revision[0].in_history(b).rev_id
2481
t = testament_class.from_revision(b.repository, rev_id)
2482
if long:
2483
sys.stdout.writelines(t.as_text_lines())
2484
else:
2485
sys.stdout.write(t.as_short_text())
2486
finally:
2487
b.unlock()
2488
2489
2490
class cmd_annotate(Command):
2491
"""Show the origin of each line in a file.
2492
2493
This prints out the given file with an annotation on the left side
2494
indicating which revision, author and date introduced the change.
2495
2496
If the origin is the same for a run of consecutive lines, it is
2497
shown only at the top, unless the --all option is given.
2498
"""
2499
# TODO: annotate directories; showing when each file was last changed
2500
# TODO: if the working copy is modified, show annotations on that
2501
# with new uncommitted lines marked
2502
aliases = ['ann', 'blame', 'praise']
2503
takes_args = ['filename']
2504
takes_options = [Option('all', help='show annotations on all lines'),
2505
Option('long', help='show date in annotations'),
2506
'revision'
2507
]
2508
2509
@display_command
2510
def run(self, filename, all=False, long=False, revision=None):
2511
from bzrlib.annotate import annotate_file
2512
tree, relpath = WorkingTree.open_containing(filename)
2513
branch = tree.branch
2514
branch.lock_read()
2515
try:
2516
if revision is None:
2517
revision_id = branch.last_revision()
2518
elif len(revision) != 1:
2519
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2520
else:
2521
revision_id = revision[0].in_history(branch).rev_id
2522
file_id = tree.inventory.path2id(relpath)
2523
tree = branch.repository.revision_tree(revision_id)
2524
file_version = tree.inventory[file_id].revision
2525
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2526
finally:
2527
branch.unlock()
2528
2529
2530
class cmd_re_sign(Command):
2531
"""Create a digital signature for an existing revision."""
2532
# TODO be able to replace existing ones.
2533
2534
hidden = True # is this right ?
2535
takes_args = ['revision_id*']
2536
takes_options = ['revision']
2537
2538
def run(self, revision_id_list=None, revision=None):
2539
import bzrlib.gpg as gpg
2540
if revision_id_list is not None and revision is not None:
2541
raise BzrCommandError('You can only supply one of revision_id or --revision')
2542
if revision_id_list is None and revision is None:
2543
raise BzrCommandError('You must supply either --revision or a revision_id')
2544
b = WorkingTree.open_containing(u'.')[0].branch
2545
gpg_strategy = gpg.GPGStrategy(b.get_config())
2546
if revision_id_list is not None:
2547
for revision_id in revision_id_list:
2548
b.repository.sign_revision(revision_id, gpg_strategy)
2549
elif revision is not None:
2550
if len(revision) == 1:
2551
revno, rev_id = revision[0].in_history(b)
2552
b.repository.sign_revision(rev_id, gpg_strategy)
2553
elif len(revision) == 2:
2554
# are they both on rh- if so we can walk between them
2555
# might be nice to have a range helper for arbitrary
2556
# revision paths. hmm.
2557
from_revno, from_revid = revision[0].in_history(b)
2558
to_revno, to_revid = revision[1].in_history(b)
2559
if to_revid is None:
2560
to_revno = b.revno()
2561
if from_revno is None or to_revno is None:
2562
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2563
for revno in range(from_revno, to_revno + 1):
2564
b.repository.sign_revision(b.get_rev_id(revno),
2565
gpg_strategy)
2566
else:
2567
raise BzrCommandError('Please supply either one revision, or a range.')
2568
2569
2570
class cmd_bind(Command):
2571
"""Bind the current branch to a master branch.
2572
2573
After binding, commits must succeed on the master branch
2574
before they are executed on the local one.
2575
"""
2576
2577
takes_args = ['location']
2578
takes_options = []
2579
2580
def run(self, location=None):
2581
b, relpath = Branch.open_containing(u'.')
2582
b_other = Branch.open(location)
2583
try:
2584
b.bind(b_other)
2585
except DivergedBranches:
2586
raise BzrCommandError('These branches have diverged.'
2587
' Try merging, and then bind again.')
2588
2589
2590
class cmd_unbind(Command):
2591
"""Unbind the current branch from its master branch.
2592
2593
After unbinding, the local branch is considered independent.
2594
All subsequent commits will be local.
2595
"""
2596
2597
takes_args = []
2598
takes_options = []
2599
2600
def run(self):
2601
b, relpath = Branch.open_containing(u'.')
2602
if not b.unbind():
2603
raise BzrCommandError('Local branch is not bound')
2604
2605
2606
class cmd_uncommit(Command):
2607
"""Remove the last committed revision.
2608
2609
--verbose will print out what is being removed.
2610
--dry-run will go through all the motions, but not actually
2611
remove anything.
2612
2613
In the future, uncommit will create a revision bundle, which can then
2614
be re-applied.
2615
"""
2616
2617
# TODO: jam 20060108 Add an option to allow uncommit to remove
2618
# unreferenced information in 'branch-as-repository' branches.
2619
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2620
# information in shared branches as well.
2621
takes_options = ['verbose', 'revision',
2622
Option('dry-run', help='Don\'t actually make changes'),
2623
Option('force', help='Say yes to all questions.')]
2624
takes_args = ['location?']
2625
aliases = []
2626
2627
def run(self, location=None,
2628
dry_run=False, verbose=False,
2629
revision=None, force=False):
2630
from bzrlib.log import log_formatter
2631
import sys
2632
from bzrlib.uncommit import uncommit
2633
2634
if location is None:
2635
location = u'.'
2636
control, relpath = bzrdir.BzrDir.open_containing(location)
2637
try:
2638
tree = control.open_workingtree()
2639
b = tree.branch
2640
except (errors.NoWorkingTree, errors.NotLocalUrl):
2641
tree = None
2642
b = control.open_branch()
2643
2644
if revision is None:
2645
revno = b.revno()
2646
rev_id = b.last_revision()
2647
else:
2648
revno, rev_id = revision[0].in_history(b)
2649
if rev_id is None:
2650
print 'No revisions to uncommit.'
2651
2652
for r in range(revno, b.revno()+1):
2653
rev_id = b.get_rev_id(r)
2654
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2655
lf.show(r, b.repository.get_revision(rev_id), None)
2656
2657
if dry_run:
2658
print 'Dry-run, pretending to remove the above revisions.'
2659
if not force:
2660
val = raw_input('Press <enter> to continue')
2661
else:
2662
print 'The above revision(s) will be removed.'
2663
if not force:
2664
val = raw_input('Are you sure [y/N]? ')
2665
if val.lower() not in ('y', 'yes'):
2666
print 'Canceled'
2667
return 0
2668
2669
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2670
revno=revno)
2671
2672
2673
class cmd_break_lock(Command):
2674
"""Break a dead lock on a repository, branch or working directory.
2675
2676
CAUTION: Locks should only be broken when you are sure that the process
2677
holding the lock has been stopped.
2678
2679
You can get information on what locks are open via the 'bzr info' command.
2680
2681
example:
2682
bzr break-lock
2683
"""
2684
takes_args = ['location?']
2685
2686
def run(self, location=None, show=False):
2687
if location is None:
2688
location = u'.'
2689
control, relpath = bzrdir.BzrDir.open_containing(location)
2690
try:
2691
control.break_lock()
2692
except NotImplementedError:
2693
pass
2694
2695
2696
2697
# command-line interpretation helper for merge-related commands
2698
def merge(other_revision, base_revision,
2699
check_clean=True, ignore_zero=False,
2700
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2701
file_list=None, show_base=False, reprocess=False,
2702
pb=DummyProgress()):
2703
"""Merge changes into a tree.
2704
2705
base_revision
2706
list(path, revno) Base for three-way merge.
2707
If [None, None] then a base will be automatically determined.
2708
other_revision
2709
list(path, revno) Other revision for three-way merge.
2710
this_dir
2711
Directory to merge changes into; '.' by default.
2712
check_clean
2713
If true, this_dir must have no uncommitted changes before the
2714
merge begins.
2715
ignore_zero - If true, suppress the "zero conflicts" message when
2716
there are no conflicts; should be set when doing something we expect
2717
to complete perfectly.
2718
file_list - If supplied, merge only changes to selected files.
2719
2720
All available ancestors of other_revision and base_revision are
2721
automatically pulled into the branch.
2722
2723
The revno may be -1 to indicate the last revision on the branch, which is
2724
the typical case.
2725
2726
This function is intended for use from the command line; programmatic
2727
clients might prefer to call merge.merge_inner(), which has less magic
2728
behavior.
2729
"""
2730
from bzrlib.merge import Merger
2731
if this_dir is None:
2732
this_dir = u'.'
2733
this_tree = WorkingTree.open_containing(this_dir)[0]
2734
if show_base and not merge_type is Merge3Merger:
2735
raise BzrCommandError("Show-base is not supported for this merge"
2736
" type. %s" % merge_type)
2737
if reprocess and not merge_type.supports_reprocess:
2738
raise BzrCommandError("Conflict reduction is not supported for merge"
2739
" type %s." % merge_type)
2740
if reprocess and show_base:
2741
raise BzrCommandError("Cannot do conflict reduction and show base.")
2742
try:
2743
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2744
merger.pp = ProgressPhase("Merge phase", 5, pb)
2745
merger.pp.next_phase()
2746
merger.check_basis(check_clean)
2747
merger.set_other(other_revision)
2748
merger.pp.next_phase()
2749
merger.set_base(base_revision)
2750
if merger.base_rev_id == merger.other_rev_id:
2751
note('Nothing to do.')
2752
return 0
2753
merger.backup_files = backup_files
2754
merger.merge_type = merge_type
2755
merger.set_interesting_files(file_list)
2756
merger.show_base = show_base
2757
merger.reprocess = reprocess
2758
conflicts = merger.do_merge()
2759
if file_list is None:
2760
merger.set_pending()
2761
finally:
2762
pb.clear()
2763
return conflicts
2764
2765
2766
# these get imported and then picked up by the scan for cmd_*
2767
# TODO: Some more consistent way to split command definitions across files;
2768
# we do need to load at least some information about them to know of
2769
# aliases. ideally we would avoid loading the implementation until the
2770
# details were needed.
2771
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2772
from bzrlib.bundle.commands import cmd_bundle_revisions
2773
from bzrlib.sign_my_commits import cmd_sign_my_commits
2774
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2775
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0