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