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