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