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