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