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