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