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