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