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