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