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