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