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