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