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 2089
- compare with another revision
- download diff
- download tarball
- view history from revision 2089
- Committer: Canonical.com Patch Queue Manager
- Date: 2006-10-19 00:05:23 UTC
- mfrom: (2079.1.2 circular-import)
- Revision ID: pqm@pqm.ubuntu.com-20061019000523-3b34ef366c1b627f
(John Arbash Meinel) avoid circular imports by properly deprecating RevisionTree
- 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
- foreign
- 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
master = tree.branch.get_master_branch()
853
if master is not None:
854
tree.lock_write()
855
else:
856
tree.lock_tree_write()
857
try:
858
existing_pending_merges = tree.get_parent_ids()[1:]
859
last_rev = tree.last_revision()
860
if last_rev == tree.branch.last_revision():
861
# may be up to date, check master too.
862
master = tree.branch.get_master_branch()
863
if master is None or last_rev == master.last_revision():
864
revno = tree.branch.revision_id_to_revno(last_rev)
865
note("Tree is up to date at revision %d." % (revno,))
866
return 0
867
conflicts = tree.update()
868
revno = tree.branch.revision_id_to_revno(tree.last_revision())
869
note('Updated to revision %d.' % (revno,))
870
if tree.get_parent_ids()[1:] != existing_pending_merges:
871
note('Your local commits will now show as pending merges with '
872
"'bzr status', and can be committed with 'bzr commit'.")
873
if conflicts != 0:
874
return 1
875
else:
876
return 0
877
finally:
878
tree.unlock()
879
880
881
class cmd_info(Command):
882
"""Show information about a working tree, branch or repository.
883
884
This command will show all known locations and formats associated to the
885
tree, branch or repository. Statistical information is included with
886
each report.
887
888
Branches and working trees will also report any missing revisions.
889
"""
890
takes_args = ['location?']
891
takes_options = ['verbose']
892
893
@display_command
894
def run(self, location=None, verbose=False):
895
from bzrlib.info import show_bzrdir_info
896
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
897
verbose=verbose)
898
899
900
class cmd_remove(Command):
901
"""Make a file unversioned.
902
903
This makes bzr stop tracking changes to a versioned file. It does
904
not delete the working copy.
905
906
You can specify one or more files, and/or --new. If you specify --new,
907
only 'added' files will be removed. If you specify both, then new files
908
in the specified directories will be removed. If the directories are
909
also new, they will also be removed.
910
"""
911
takes_args = ['file*']
912
takes_options = ['verbose', Option('new', help='remove newly-added files')]
913
aliases = ['rm']
914
encoding_type = 'replace'
915
916
def run(self, file_list, verbose=False, new=False):
917
tree, file_list = tree_files(file_list)
918
if new is False:
919
if file_list is None:
920
raise errors.BzrCommandError('Specify one or more files to'
921
' remove, or use --new.')
922
else:
923
added = tree.changes_from(tree.basis_tree(),
924
specific_files=file_list).added
925
file_list = sorted([f[0] for f in added], reverse=True)
926
if len(file_list) == 0:
927
raise errors.BzrCommandError('No matching files.')
928
tree.remove(file_list, verbose=verbose, to_file=self.outf)
929
930
931
class cmd_file_id(Command):
932
"""Print file_id of a particular file or directory.
933
934
The file_id is assigned when the file is first added and remains the
935
same through all revisions where the file exists, even when it is
936
moved or renamed.
937
"""
938
939
hidden = True
940
takes_args = ['filename']
941
942
@display_command
943
def run(self, filename):
944
tree, relpath = WorkingTree.open_containing(filename)
945
i = tree.inventory.path2id(relpath)
946
if i is None:
947
raise errors.BzrError("%r is not a versioned file" % filename)
948
else:
949
self.outf.write(i + '\n')
950
951
952
class cmd_file_path(Command):
953
"""Print path of file_ids to a file or directory.
954
955
This prints one line for each directory down to the target,
956
starting at the branch root.
957
"""
958
959
hidden = True
960
takes_args = ['filename']
961
962
@display_command
963
def run(self, filename):
964
tree, relpath = WorkingTree.open_containing(filename)
965
inv = tree.inventory
966
fid = inv.path2id(relpath)
967
if fid is None:
968
raise errors.BzrError("%r is not a versioned file" % filename)
969
for fip in inv.get_idpath(fid):
970
self.outf.write(fip + '\n')
971
972
973
class cmd_reconcile(Command):
974
"""Reconcile bzr metadata in a branch.
975
976
This can correct data mismatches that may have been caused by
977
previous ghost operations or bzr upgrades. You should only
978
need to run this command if 'bzr check' or a bzr developer
979
advises you to run it.
980
981
If a second branch is provided, cross-branch reconciliation is
982
also attempted, which will check that data like the tree root
983
id which was not present in very early bzr versions is represented
984
correctly in both branches.
985
986
At the same time it is run it may recompress data resulting in
987
a potential saving in disk space or performance gain.
988
989
The branch *MUST* be on a listable system such as local disk or sftp.
990
"""
991
takes_args = ['branch?']
992
993
def run(self, branch="."):
994
from bzrlib.reconcile import reconcile
995
dir = bzrdir.BzrDir.open(branch)
996
reconcile(dir)
997
998
999
class cmd_revision_history(Command):
1000
"""Display the list of revision ids on a branch."""
1001
takes_args = ['location?']
1002
1003
hidden = True
1004
1005
@display_command
1006
def run(self, location="."):
1007
branch = Branch.open_containing(location)[0]
1008
for revid in branch.revision_history():
1009
self.outf.write(revid)
1010
self.outf.write('\n')
1011
1012
1013
class cmd_ancestry(Command):
1014
"""List all revisions merged into this branch."""
1015
takes_args = ['location?']
1016
1017
hidden = True
1018
1019
@display_command
1020
def run(self, location="."):
1021
try:
1022
wt = WorkingTree.open_containing(location)[0]
1023
except errors.NoWorkingTree:
1024
b = Branch.open(location)
1025
last_revision = b.last_revision()
1026
else:
1027
b = wt.branch
1028
last_revision = wt.last_revision()
1029
1030
revision_ids = b.repository.get_ancestry(last_revision)
1031
assert revision_ids[0] is None
1032
revision_ids.pop(0)
1033
for revision_id in revision_ids:
1034
self.outf.write(revision_id + '\n')
1035
1036
1037
class cmd_init(Command):
1038
"""Make a directory into a versioned branch.
1039
1040
Use this to create an empty branch, or before importing an
1041
existing project.
1042
1043
If there is a repository in a parent directory of the location, then
1044
the history of the branch will be stored in the repository. Otherwise
1045
init creates a standalone branch which carries its own history in
1046
.bzr.
1047
1048
If there is already a branch at the location but it has no working tree,
1049
the tree can be populated with 'bzr checkout'.
1050
1051
Recipe for importing a tree of files:
1052
cd ~/project
1053
bzr init
1054
bzr add .
1055
bzr status
1056
bzr commit -m 'imported project'
1057
"""
1058
takes_args = ['location?']
1059
takes_options = [
1060
Option('format',
1061
help='Specify a format for this branch. Current'
1062
' formats are: default, knit, metaweave and'
1063
' weave. Default is knit; metaweave and'
1064
' weave are deprecated',
1065
type=get_format_type),
1066
]
1067
def run(self, location=None, format=None):
1068
if format is None:
1069
format = get_format_type('default')
1070
if location is None:
1071
location = u'.'
1072
1073
to_transport = transport.get_transport(location)
1074
1075
# The path has to exist to initialize a
1076
# branch inside of it.
1077
# Just using os.mkdir, since I don't
1078
# believe that we want to create a bunch of
1079
# locations if the user supplies an extended path
1080
# TODO: create-prefix
1081
try:
1082
to_transport.mkdir('.')
1083
except errors.FileExists:
1084
pass
1085
1086
try:
1087
existing_bzrdir = bzrdir.BzrDir.open(location)
1088
except errors.NotBranchError:
1089
# really a NotBzrDir error...
1090
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1091
else:
1092
from bzrlib.transport.local import LocalTransport
1093
if existing_bzrdir.has_branch():
1094
if (isinstance(to_transport, LocalTransport)
1095
and not existing_bzrdir.has_workingtree()):
1096
raise errors.BranchExistsWithoutWorkingTree(location)
1097
raise errors.AlreadyBranchError(location)
1098
else:
1099
existing_bzrdir.create_branch()
1100
existing_bzrdir.create_workingtree()
1101
1102
1103
class cmd_init_repository(Command):
1104
"""Create a shared repository to hold branches.
1105
1106
New branches created under the repository directory will store their revisions
1107
in the repository, not in the branch directory, if the branch format supports
1108
shared storage.
1109
1110
example:
1111
bzr init-repo repo
1112
bzr init repo/trunk
1113
bzr checkout --lightweight repo/trunk trunk-checkout
1114
cd trunk-checkout
1115
(add files here)
1116
"""
1117
takes_args = ["location"]
1118
takes_options = [Option('format',
1119
help='Specify a format for this repository.'
1120
' Current formats are: default, knit,'
1121
' metaweave and weave. Default is knit;'
1122
' metaweave and weave are deprecated',
1123
type=get_format_type),
1124
Option('trees',
1125
help='Allows branches in repository to have'
1126
' a working tree')]
1127
aliases = ["init-repo"]
1128
def run(self, location, format=None, trees=False):
1129
if format is None:
1130
format = get_format_type('default')
1131
1132
if location is None:
1133
location = '.'
1134
1135
to_transport = transport.get_transport(location)
1136
try:
1137
to_transport.mkdir('.')
1138
except errors.FileExists:
1139
pass
1140
1141
newdir = format.initialize_on_transport(to_transport)
1142
repo = newdir.create_repository(shared=True)
1143
repo.set_make_working_trees(trees)
1144
1145
1146
class cmd_diff(Command):
1147
"""Show differences in the working tree or between revisions.
1148
1149
If files are listed, only the changes in those files are listed.
1150
Otherwise, all changes for the tree are listed.
1151
1152
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1153
produces patches suitable for "patch -p1".
1154
1155
examples:
1156
bzr diff
1157
Shows the difference in the working tree versus the last commit
1158
bzr diff -r1
1159
Difference between the working tree and revision 1
1160
bzr diff -r1..2
1161
Difference between revision 2 and revision 1
1162
bzr diff --diff-prefix old/:new/
1163
Same as 'bzr diff' but prefix paths with old/ and new/
1164
bzr diff bzr.mine bzr.dev
1165
Show the differences between the two working trees
1166
bzr diff foo.c
1167
Show just the differences for 'foo.c'
1168
"""
1169
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1170
# or a graphical diff.
1171
1172
# TODO: Python difflib is not exactly the same as unidiff; should
1173
# either fix it up or prefer to use an external diff.
1174
1175
# TODO: Selected-file diff is inefficient and doesn't show you
1176
# deleted files.
1177
1178
# TODO: This probably handles non-Unix newlines poorly.
1179
1180
takes_args = ['file*']
1181
takes_options = ['revision', 'diff-options', 'prefix']
1182
aliases = ['di', 'dif']
1183
encoding_type = 'exact'
1184
1185
@display_command
1186
def run(self, revision=None, file_list=None, diff_options=None,
1187
prefix=None):
1188
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1189
1190
if (prefix is None) or (prefix == '0'):
1191
# diff -p0 format
1192
old_label = ''
1193
new_label = ''
1194
elif prefix == '1':
1195
old_label = 'old/'
1196
new_label = 'new/'
1197
else:
1198
if not ':' in prefix:
1199
raise errors.BzrError("--diff-prefix expects two values"
1200
" separated by a colon")
1201
old_label, new_label = prefix.split(":")
1202
1203
try:
1204
tree1, file_list = internal_tree_files(file_list)
1205
tree2 = None
1206
b = None
1207
b2 = None
1208
except errors.FileInWrongBranch:
1209
if len(file_list) != 2:
1210
raise errors.BzrCommandError("Files are in different branches")
1211
1212
tree1, file1 = WorkingTree.open_containing(file_list[0])
1213
tree2, file2 = WorkingTree.open_containing(file_list[1])
1214
if file1 != "" or file2 != "":
1215
# FIXME diff those two files. rbc 20051123
1216
raise errors.BzrCommandError("Files are in different branches")
1217
file_list = None
1218
except errors.NotBranchError:
1219
if (revision is not None and len(revision) == 2
1220
and not revision[0].needs_branch()
1221
and not revision[1].needs_branch()):
1222
# If both revision specs include a branch, we can
1223
# diff them without needing a local working tree
1224
tree1, tree2 = None, None
1225
else:
1226
raise
1227
if revision is not None:
1228
if tree2 is not None:
1229
raise errors.BzrCommandError("Can't specify -r with two branches")
1230
if (len(revision) == 1) or (revision[1].spec is None):
1231
return diff_cmd_helper(tree1, file_list, diff_options,
1232
revision[0],
1233
old_label=old_label, new_label=new_label)
1234
elif len(revision) == 2:
1235
return diff_cmd_helper(tree1, file_list, diff_options,
1236
revision[0], revision[1],
1237
old_label=old_label, new_label=new_label)
1238
else:
1239
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1240
' one or two revision identifiers')
1241
else:
1242
if tree2 is not None:
1243
return show_diff_trees(tree1, tree2, sys.stdout,
1244
specific_files=file_list,
1245
external_diff_options=diff_options,
1246
old_label=old_label, new_label=new_label)
1247
else:
1248
return diff_cmd_helper(tree1, file_list, diff_options,
1249
old_label=old_label, new_label=new_label)
1250
1251
1252
class cmd_deleted(Command):
1253
"""List files deleted in the working tree.
1254
"""
1255
# TODO: Show files deleted since a previous revision, or
1256
# between two revisions.
1257
# TODO: Much more efficient way to do this: read in new
1258
# directories with readdir, rather than stating each one. Same
1259
# level of effort but possibly much less IO. (Or possibly not,
1260
# if the directories are very large...)
1261
takes_options = ['show-ids']
1262
1263
@display_command
1264
def run(self, show_ids=False):
1265
tree = WorkingTree.open_containing(u'.')[0]
1266
old = tree.basis_tree()
1267
for path, ie in old.inventory.iter_entries():
1268
if not tree.has_id(ie.file_id):
1269
self.outf.write(path)
1270
if show_ids:
1271
self.outf.write(' ')
1272
self.outf.write(ie.file_id)
1273
self.outf.write('\n')
1274
1275
1276
class cmd_modified(Command):
1277
"""List files modified in working tree."""
1278
hidden = True
1279
@display_command
1280
def run(self):
1281
tree = WorkingTree.open_containing(u'.')[0]
1282
td = tree.changes_from(tree.basis_tree())
1283
for path, id, kind, text_modified, meta_modified in td.modified:
1284
self.outf.write(path + '\n')
1285
1286
1287
class cmd_added(Command):
1288
"""List files added in working tree."""
1289
hidden = True
1290
@display_command
1291
def run(self):
1292
wt = WorkingTree.open_containing(u'.')[0]
1293
basis_inv = wt.basis_tree().inventory
1294
inv = wt.inventory
1295
for file_id in inv:
1296
if file_id in basis_inv:
1297
continue
1298
if inv.is_root(file_id) and len(basis_inv) == 0:
1299
continue
1300
path = inv.id2path(file_id)
1301
if not os.access(osutils.abspath(path), os.F_OK):
1302
continue
1303
self.outf.write(path + '\n')
1304
1305
1306
class cmd_root(Command):
1307
"""Show the tree root directory.
1308
1309
The root is the nearest enclosing directory with a .bzr control
1310
directory."""
1311
takes_args = ['filename?']
1312
@display_command
1313
def run(self, filename=None):
1314
"""Print the branch root."""
1315
tree = WorkingTree.open_containing(filename)[0]
1316
self.outf.write(tree.basedir + '\n')
1317
1318
1319
class cmd_log(Command):
1320
"""Show log of a branch, file, or directory.
1321
1322
By default show the log of the branch containing the working directory.
1323
1324
To request a range of logs, you can use the command -r begin..end
1325
-r revision requests a specific revision, -r ..end or -r begin.. are
1326
also valid.
1327
1328
examples:
1329
bzr log
1330
bzr log foo.c
1331
bzr log -r -10.. http://server/branch
1332
"""
1333
1334
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1335
1336
takes_args = ['location?']
1337
takes_options = [Option('forward',
1338
help='show from oldest to newest'),
1339
'timezone',
1340
Option('verbose',
1341
help='show files changed in each revision'),
1342
'show-ids', 'revision',
1343
'log-format',
1344
'line', 'long',
1345
Option('message',
1346
help='show revisions whose message matches this regexp',
1347
type=str),
1348
'short',
1349
]
1350
encoding_type = 'replace'
1351
1352
@display_command
1353
def run(self, location=None, timezone='original',
1354
verbose=False,
1355
show_ids=False,
1356
forward=False,
1357
revision=None,
1358
log_format=None,
1359
message=None,
1360
long=False,
1361
short=False,
1362
line=False):
1363
from bzrlib.log import log_formatter, show_log
1364
assert message is None or isinstance(message, basestring), \
1365
"invalid message argument %r" % message
1366
direction = (forward and 'forward') or 'reverse'
1367
1368
# log everything
1369
file_id = None
1370
if location:
1371
# find the file id to log:
1372
1373
dir, fp = bzrdir.BzrDir.open_containing(location)
1374
b = dir.open_branch()
1375
if fp != '':
1376
try:
1377
# might be a tree:
1378
inv = dir.open_workingtree().inventory
1379
except (errors.NotBranchError, errors.NotLocalUrl):
1380
# either no tree, or is remote.
1381
inv = b.basis_tree().inventory
1382
file_id = inv.path2id(fp)
1383
else:
1384
# local dir only
1385
# FIXME ? log the current subdir only RBC 20060203
1386
if revision is not None \
1387
and len(revision) > 0 and revision[0].get_branch():
1388
location = revision[0].get_branch()
1389
else:
1390
location = '.'
1391
dir, relpath = bzrdir.BzrDir.open_containing(location)
1392
b = dir.open_branch()
1393
1394
if revision is None:
1395
rev1 = None
1396
rev2 = None
1397
elif len(revision) == 1:
1398
rev1 = rev2 = revision[0].in_history(b).revno
1399
elif len(revision) == 2:
1400
if revision[1].get_branch() != revision[0].get_branch():
1401
# b is taken from revision[0].get_branch(), and
1402
# show_log will use its revision_history. Having
1403
# different branches will lead to weird behaviors.
1404
raise errors.BzrCommandError(
1405
"Log doesn't accept two revisions in different branches.")
1406
if revision[0].spec is None:
1407
# missing begin-range means first revision
1408
rev1 = 1
1409
else:
1410
rev1 = revision[0].in_history(b).revno
1411
1412
if revision[1].spec is None:
1413
# missing end-range means last known revision
1414
rev2 = b.revno()
1415
else:
1416
rev2 = revision[1].in_history(b).revno
1417
else:
1418
raise errors.BzrCommandError('bzr log --revision takes one or two values.')
1419
1420
# By this point, the revision numbers are converted to the +ve
1421
# form if they were supplied in the -ve form, so we can do
1422
# this comparison in relative safety
1423
if rev1 > rev2:
1424
(rev2, rev1) = (rev1, rev2)
1425
1426
if (log_format is None):
1427
default = b.get_config().log_format()
1428
log_format = get_log_format(long=long, short=short, line=line,
1429
default=default)
1430
lf = log_formatter(log_format,
1431
show_ids=show_ids,
1432
to_file=self.outf,
1433
show_timezone=timezone)
1434
1435
show_log(b,
1436
lf,
1437
file_id,
1438
verbose=verbose,
1439
direction=direction,
1440
start_revision=rev1,
1441
end_revision=rev2,
1442
search=message)
1443
1444
1445
def get_log_format(long=False, short=False, line=False, default='long'):
1446
log_format = default
1447
if long:
1448
log_format = 'long'
1449
if short:
1450
log_format = 'short'
1451
if line:
1452
log_format = 'line'
1453
return log_format
1454
1455
1456
class cmd_touching_revisions(Command):
1457
"""Return revision-ids which affected a particular file.
1458
1459
A more user-friendly interface is "bzr log FILE".
1460
"""
1461
1462
hidden = True
1463
takes_args = ["filename"]
1464
1465
@display_command
1466
def run(self, filename):
1467
tree, relpath = WorkingTree.open_containing(filename)
1468
b = tree.branch
1469
inv = tree.read_working_inventory()
1470
file_id = inv.path2id(relpath)
1471
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1472
self.outf.write("%6d %s\n" % (revno, what))
1473
1474
1475
class cmd_ls(Command):
1476
"""List files in a tree.
1477
"""
1478
# TODO: Take a revision or remote path and list that tree instead.
1479
hidden = True
1480
takes_options = ['verbose', 'revision',
1481
Option('non-recursive',
1482
help='don\'t recurse into sub-directories'),
1483
Option('from-root',
1484
help='Print all paths from the root of the branch.'),
1485
Option('unknown', help='Print unknown files'),
1486
Option('versioned', help='Print versioned files'),
1487
Option('ignored', help='Print ignored files'),
1488
1489
Option('null', help='Null separate the files'),
1490
]
1491
@display_command
1492
def run(self, revision=None, verbose=False,
1493
non_recursive=False, from_root=False,
1494
unknown=False, versioned=False, ignored=False,
1495
null=False):
1496
1497
if verbose and null:
1498
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1499
all = not (unknown or versioned or ignored)
1500
1501
selection = {'I':ignored, '?':unknown, 'V':versioned}
1502
1503
tree, relpath = WorkingTree.open_containing(u'.')
1504
if from_root:
1505
relpath = u''
1506
elif relpath:
1507
relpath += '/'
1508
if revision is not None:
1509
tree = tree.branch.repository.revision_tree(
1510
revision[0].in_history(tree.branch).rev_id)
1511
1512
for fp, fc, kind, fid, entry in tree.list_files(include_root=False):
1513
if fp.startswith(relpath):
1514
fp = fp[len(relpath):]
1515
if non_recursive and '/' in fp:
1516
continue
1517
if not all and not selection[fc]:
1518
continue
1519
if verbose:
1520
kindch = entry.kind_character()
1521
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1522
elif null:
1523
self.outf.write(fp + '\0')
1524
self.outf.flush()
1525
else:
1526
self.outf.write(fp + '\n')
1527
1528
1529
class cmd_unknowns(Command):
1530
"""List unknown files."""
1531
@display_command
1532
def run(self):
1533
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1534
self.outf.write(osutils.quotefn(f) + '\n')
1535
1536
1537
class cmd_ignore(Command):
1538
"""Ignore a command or pattern.
1539
1540
To remove patterns from the ignore list, edit the .bzrignore file.
1541
1542
If the pattern contains a slash, it is compared to the whole path
1543
from the branch root. Otherwise, it is compared to only the last
1544
component of the path. To match a file only in the root directory,
1545
prepend './'.
1546
1547
Ignore patterns are case-insensitive on case-insensitive systems.
1548
1549
Note: wildcards must be quoted from the shell on Unix.
1550
1551
examples:
1552
bzr ignore ./Makefile
1553
bzr ignore '*.class'
1554
"""
1555
# TODO: Complain if the filename is absolute
1556
takes_args = ['name_pattern?']
1557
takes_options = [
1558
Option('old-default-rules',
1559
help='Out the ignore rules bzr < 0.9 always used.')
1560
]
1561
1562
def run(self, name_pattern=None, old_default_rules=None):
1563
from bzrlib.atomicfile import AtomicFile
1564
if old_default_rules is not None:
1565
# dump the rules and exit
1566
for pattern in ignores.OLD_DEFAULTS:
1567
print pattern
1568
return
1569
if name_pattern is None:
1570
raise errors.BzrCommandError("ignore requires a NAME_PATTERN")
1571
tree, relpath = WorkingTree.open_containing(u'.')
1572
ifn = tree.abspath('.bzrignore')
1573
if os.path.exists(ifn):
1574
f = open(ifn, 'rt')
1575
try:
1576
igns = f.read().decode('utf-8')
1577
finally:
1578
f.close()
1579
else:
1580
igns = ''
1581
1582
# TODO: If the file already uses crlf-style termination, maybe
1583
# we should use that for the newly added lines?
1584
1585
if igns and igns[-1] != '\n':
1586
igns += '\n'
1587
igns += name_pattern + '\n'
1588
1589
f = AtomicFile(ifn, 'wt')
1590
try:
1591
f.write(igns.encode('utf-8'))
1592
f.commit()
1593
finally:
1594
f.close()
1595
1596
inv = tree.inventory
1597
if inv.path2id('.bzrignore'):
1598
mutter('.bzrignore is already versioned')
1599
else:
1600
mutter('need to make new .bzrignore file versioned')
1601
tree.add(['.bzrignore'])
1602
1603
1604
class cmd_ignored(Command):
1605
"""List ignored files and the patterns that matched them.
1606
1607
See also: bzr ignore"""
1608
@display_command
1609
def run(self):
1610
tree = WorkingTree.open_containing(u'.')[0]
1611
for path, file_class, kind, file_id, entry in tree.list_files():
1612
if file_class != 'I':
1613
continue
1614
## XXX: Slightly inefficient since this was already calculated
1615
pat = tree.is_ignored(path)
1616
print '%-50s %s' % (path, pat)
1617
1618
1619
class cmd_lookup_revision(Command):
1620
"""Lookup the revision-id from a revision-number
1621
1622
example:
1623
bzr lookup-revision 33
1624
"""
1625
hidden = True
1626
takes_args = ['revno']
1627
1628
@display_command
1629
def run(self, revno):
1630
try:
1631
revno = int(revno)
1632
except ValueError:
1633
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
1634
1635
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1636
1637
1638
class cmd_export(Command):
1639
"""Export past revision to destination directory.
1640
1641
If no revision is specified this exports the last committed revision.
1642
1643
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1644
given, try to find the format with the extension. If no extension
1645
is found exports to a directory (equivalent to --format=dir).
1646
1647
Root may be the top directory for tar, tgz and tbz2 formats. If none
1648
is given, the top directory will be the root name of the file.
1649
1650
Note: export of tree with non-ascii filenames to zip is not supported.
1651
1652
Supported formats Autodetected by extension
1653
----------------- -------------------------
1654
dir -
1655
tar .tar
1656
tbz2 .tar.bz2, .tbz2
1657
tgz .tar.gz, .tgz
1658
zip .zip
1659
"""
1660
takes_args = ['dest']
1661
takes_options = ['revision', 'format', 'root']
1662
def run(self, dest, revision=None, format=None, root=None):
1663
from bzrlib.export import export
1664
tree = WorkingTree.open_containing(u'.')[0]
1665
b = tree.branch
1666
if revision is None:
1667
# should be tree.last_revision FIXME
1668
rev_id = b.last_revision()
1669
else:
1670
if len(revision) != 1:
1671
raise errors.BzrError('bzr export --revision takes exactly'
1672
' 1 argument')
1673
rev_id = revision[0].in_history(b).rev_id
1674
t = b.repository.revision_tree(rev_id)
1675
try:
1676
export(t, dest, format, root)
1677
except errors.NoSuchExportFormat, e:
1678
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
1679
1680
1681
class cmd_cat(Command):
1682
"""Write a file's text from a previous revision."""
1683
1684
takes_options = ['revision']
1685
takes_args = ['filename']
1686
1687
@display_command
1688
def run(self, filename, revision=None):
1689
if revision is not None and len(revision) != 1:
1690
raise errors.BzrCommandError("bzr cat --revision takes exactly one number")
1691
tree = None
1692
try:
1693
tree, relpath = WorkingTree.open_containing(filename)
1694
b = tree.branch
1695
except errors.NotBranchError:
1696
pass
1697
1698
if tree is None:
1699
b, relpath = Branch.open_containing(filename)
1700
if revision is not None and revision[0].get_branch() is not None:
1701
b = Branch.open(revision[0].get_branch())
1702
if revision is None:
1703
revision_id = b.last_revision()
1704
else:
1705
revision_id = revision[0].in_history(b).rev_id
1706
b.print_file(relpath, revision_id)
1707
1708
1709
class cmd_local_time_offset(Command):
1710
"""Show the offset in seconds from GMT to local time."""
1711
hidden = True
1712
@display_command
1713
def run(self):
1714
print osutils.local_time_offset()
1715
1716
1717
1718
class cmd_commit(Command):
1719
"""Commit changes into a new revision.
1720
1721
If no arguments are given, the entire tree is committed.
1722
1723
If selected files are specified, only changes to those files are
1724
committed. If a directory is specified then the directory and everything
1725
within it is committed.
1726
1727
A selected-file commit may fail in some cases where the committed
1728
tree would be invalid, such as trying to commit a file in a
1729
newly-added directory that is not itself committed.
1730
"""
1731
# TODO: Run hooks on tree to-be-committed, and after commit.
1732
1733
# TODO: Strict commit that fails if there are deleted files.
1734
# (what does "deleted files" mean ??)
1735
1736
# TODO: Give better message for -s, --summary, used by tla people
1737
1738
# XXX: verbose currently does nothing
1739
1740
takes_args = ['selected*']
1741
takes_options = ['message', 'verbose',
1742
Option('unchanged',
1743
help='commit even if nothing has changed'),
1744
Option('file', type=str,
1745
argname='msgfile',
1746
help='file containing commit message'),
1747
Option('strict',
1748
help="refuse to commit if there are unknown "
1749
"files in the working tree."),
1750
Option('local',
1751
help="perform a local only commit in a bound "
1752
"branch. Such commits are not pushed to "
1753
"the master branch until a normal commit "
1754
"is performed."
1755
),
1756
]
1757
aliases = ['ci', 'checkin']
1758
1759
def run(self, message=None, file=None, verbose=True, selected_list=None,
1760
unchanged=False, strict=False, local=False):
1761
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1762
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1763
StrictCommitFailed)
1764
from bzrlib.msgeditor import edit_commit_message, \
1765
make_commit_message_template
1766
from tempfile import TemporaryFile
1767
1768
# TODO: Need a blackbox test for invoking the external editor; may be
1769
# slightly problematic to run this cross-platform.
1770
1771
# TODO: do more checks that the commit will succeed before
1772
# spending the user's valuable time typing a commit message.
1773
#
1774
# TODO: if the commit *does* happen to fail, then save the commit
1775
# message to a temporary file where it can be recovered
1776
tree, selected_list = tree_files(selected_list)
1777
if selected_list == ['']:
1778
# workaround - commit of root of tree should be exactly the same
1779
# as just default commit in that tree, and succeed even though
1780
# selected-file merge commit is not done yet
1781
selected_list = []
1782
1783
if local and not tree.branch.get_bound_location():
1784
raise errors.LocalRequiresBoundBranch()
1785
if message is None and not file:
1786
template = make_commit_message_template(tree, selected_list)
1787
message = edit_commit_message(template)
1788
if message is None:
1789
raise errors.BzrCommandError("please specify a commit message"
1790
" with either --message or --file")
1791
elif message and file:
1792
raise errors.BzrCommandError("please specify either --message or --file")
1793
1794
if file:
1795
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1796
1797
if message == "":
1798
raise errors.BzrCommandError("empty commit message specified")
1799
1800
if verbose:
1801
reporter = ReportCommitToLog()
1802
else:
1803
reporter = NullCommitReporter()
1804
1805
try:
1806
tree.commit(message, specific_files=selected_list,
1807
allow_pointless=unchanged, strict=strict, local=local,
1808
reporter=reporter)
1809
except PointlessCommit:
1810
# FIXME: This should really happen before the file is read in;
1811
# perhaps prepare the commit; get the message; then actually commit
1812
raise errors.BzrCommandError("no changes to commit."
1813
" use --unchanged to commit anyhow")
1814
except ConflictsInTree:
1815
raise errors.BzrCommandError("Conflicts detected in working tree. "
1816
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1817
except StrictCommitFailed:
1818
raise errors.BzrCommandError("Commit refused because there are unknown "
1819
"files in the working tree.")
1820
except errors.BoundBranchOutOfDate, e:
1821
raise errors.BzrCommandError(str(e) + "\n"
1822
'To commit to master branch, run update and then commit.\n'
1823
'You can also pass --local to commit to continue working '
1824
'disconnected.')
1825
1826
class cmd_check(Command):
1827
"""Validate consistency of branch history.
1828
1829
This command checks various invariants about the branch storage to
1830
detect data corruption or bzr bugs.
1831
"""
1832
takes_args = ['branch?']
1833
takes_options = ['verbose']
1834
1835
def run(self, branch=None, verbose=False):
1836
from bzrlib.check import check
1837
if branch is None:
1838
tree = WorkingTree.open_containing()[0]
1839
branch = tree.branch
1840
else:
1841
branch = Branch.open(branch)
1842
check(branch, verbose)
1843
1844
1845
class cmd_scan_cache(Command):
1846
hidden = True
1847
def run(self):
1848
from bzrlib.hashcache import HashCache
1849
1850
c = HashCache(u'.')
1851
c.read()
1852
c.scan()
1853
1854
print '%6d stats' % c.stat_count
1855
print '%6d in hashcache' % len(c._cache)
1856
print '%6d files removed from cache' % c.removed_count
1857
print '%6d hashes updated' % c.update_count
1858
print '%6d files changed too recently to cache' % c.danger_count
1859
1860
if c.needs_write:
1861
c.write()
1862
1863
1864
class cmd_upgrade(Command):
1865
"""Upgrade branch storage to current format.
1866
1867
The check command or bzr developers may sometimes advise you to run
1868
this command. When the default format has changed you may also be warned
1869
during other operations to upgrade.
1870
"""
1871
takes_args = ['url?']
1872
takes_options = [
1873
Option('format',
1874
help='Upgrade to a specific format. Current formats'
1875
' are: default, knit, metaweave and weave.'
1876
' Default is knit; metaweave and weave are'
1877
' deprecated',
1878
type=get_format_type),
1879
]
1880
1881
1882
def run(self, url='.', format=None):
1883
from bzrlib.upgrade import upgrade
1884
if format is None:
1885
format = get_format_type('default')
1886
upgrade(url, format)
1887
1888
1889
class cmd_whoami(Command):
1890
"""Show or set bzr user id.
1891
1892
examples:
1893
bzr whoami --email
1894
bzr whoami 'Frank Chu <fchu@example.com>'
1895
"""
1896
takes_options = [ Option('email',
1897
help='display email address only'),
1898
Option('branch',
1899
help='set identity for the current branch instead of '
1900
'globally'),
1901
]
1902
takes_args = ['name?']
1903
encoding_type = 'replace'
1904
1905
@display_command
1906
def run(self, email=False, branch=False, name=None):
1907
if name is None:
1908
# use branch if we're inside one; otherwise global config
1909
try:
1910
c = Branch.open_containing('.')[0].get_config()
1911
except errors.NotBranchError:
1912
c = config.GlobalConfig()
1913
if email:
1914
self.outf.write(c.user_email() + '\n')
1915
else:
1916
self.outf.write(c.username() + '\n')
1917
return
1918
1919
# display a warning if an email address isn't included in the given name.
1920
try:
1921
config.extract_email_address(name)
1922
except errors.NoEmailInUsername, e:
1923
warning('"%s" does not seem to contain an email address. '
1924
'This is allowed, but not recommended.', name)
1925
1926
# use global config unless --branch given
1927
if branch:
1928
c = Branch.open_containing('.')[0].get_config()
1929
else:
1930
c = config.GlobalConfig()
1931
c.set_user_option('email', name)
1932
1933
1934
class cmd_nick(Command):
1935
"""Print or set the branch nickname.
1936
1937
If unset, the tree root directory name is used as the nickname
1938
To print the current nickname, execute with no argument.
1939
"""
1940
takes_args = ['nickname?']
1941
def run(self, nickname=None):
1942
branch = Branch.open_containing(u'.')[0]
1943
if nickname is None:
1944
self.printme(branch)
1945
else:
1946
branch.nick = nickname
1947
1948
@display_command
1949
def printme(self, branch):
1950
print branch.nick
1951
1952
1953
class cmd_selftest(Command):
1954
"""Run internal test suite.
1955
1956
This creates temporary test directories in the working directory,
1957
but not existing data is affected. These directories are deleted
1958
if the tests pass, or left behind to help in debugging if they
1959
fail and --keep-output is specified.
1960
1961
If arguments are given, they are regular expressions that say
1962
which tests should run.
1963
1964
If the global option '--no-plugins' is given, plugins are not loaded
1965
before running the selftests. This has two effects: features provided or
1966
modified by plugins will not be tested, and tests provided by plugins will
1967
not be run.
1968
1969
examples:
1970
bzr selftest ignore
1971
bzr --no-plugins selftest -v
1972
"""
1973
# TODO: --list should give a list of all available tests
1974
1975
# NB: this is used from the class without creating an instance, which is
1976
# why it does not have a self parameter.
1977
def get_transport_type(typestring):
1978
"""Parse and return a transport specifier."""
1979
if typestring == "sftp":
1980
from bzrlib.transport.sftp import SFTPAbsoluteServer
1981
return SFTPAbsoluteServer
1982
if typestring == "memory":
1983
from bzrlib.transport.memory import MemoryServer
1984
return MemoryServer
1985
if typestring == "fakenfs":
1986
from bzrlib.transport.fakenfs import FakeNFSServer
1987
return FakeNFSServer
1988
msg = "No known transport type %s. Supported types are: sftp\n" %\
1989
(typestring)
1990
raise errors.BzrCommandError(msg)
1991
1992
hidden = True
1993
takes_args = ['testspecs*']
1994
takes_options = ['verbose',
1995
Option('one', help='stop when one test fails'),
1996
Option('keep-output',
1997
help='keep output directories when tests fail'),
1998
Option('transport',
1999
help='Use a different transport by default '
2000
'throughout the test suite.',
2001
type=get_transport_type),
2002
Option('benchmark', help='run the bzr bencharks.'),
2003
Option('lsprof-timed',
2004
help='generate lsprof output for benchmarked'
2005
' sections of code.'),
2006
Option('cache-dir', type=str,
2007
help='a directory to cache intermediate'
2008
' benchmark steps'),
2009
]
2010
2011
def run(self, testspecs_list=None, verbose=None, one=False,
2012
keep_output=False, transport=None, benchmark=None,
2013
lsprof_timed=None, cache_dir=None):
2014
import bzrlib.ui
2015
from bzrlib.tests import selftest
2016
import bzrlib.benchmarks as benchmarks
2017
from bzrlib.benchmarks import tree_creator
2018
2019
if cache_dir is not None:
2020
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2021
# we don't want progress meters from the tests to go to the
2022
# real output; and we don't want log messages cluttering up
2023
# the real logs.
2024
save_ui = ui.ui_factory
2025
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
2026
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2027
print
2028
info('running tests...')
2029
try:
2030
ui.ui_factory = ui.SilentUIFactory()
2031
if testspecs_list is not None:
2032
pattern = '|'.join(testspecs_list)
2033
else:
2034
pattern = ".*"
2035
if benchmark:
2036
test_suite_factory = benchmarks.test_suite
2037
if verbose is None:
2038
verbose = True
2039
# TODO: should possibly lock the history file...
2040
benchfile = open(".perf_history", "at")
2041
else:
2042
test_suite_factory = None
2043
if verbose is None:
2044
verbose = False
2045
benchfile = None
2046
try:
2047
result = selftest(verbose=verbose,
2048
pattern=pattern,
2049
stop_on_failure=one,
2050
keep_output=keep_output,
2051
transport=transport,
2052
test_suite_factory=test_suite_factory,
2053
lsprof_timed=lsprof_timed,
2054
bench_history=benchfile)
2055
finally:
2056
if benchfile is not None:
2057
benchfile.close()
2058
if result:
2059
info('tests passed')
2060
else:
2061
info('tests failed')
2062
return int(not result)
2063
finally:
2064
ui.ui_factory = save_ui
2065
2066
2067
class cmd_version(Command):
2068
"""Show version of bzr."""
2069
2070
@display_command
2071
def run(self):
2072
from bzrlib.version import show_version
2073
show_version()
2074
2075
2076
class cmd_rocks(Command):
2077
"""Statement of optimism."""
2078
2079
hidden = True
2080
2081
@display_command
2082
def run(self):
2083
print "it sure does!"
2084
2085
2086
class cmd_find_merge_base(Command):
2087
"""Find and print a base revision for merging two branches."""
2088
# TODO: Options to specify revisions on either side, as if
2089
# merging only part of the history.
2090
takes_args = ['branch', 'other']
2091
hidden = True
2092
2093
@display_command
2094
def run(self, branch, other):
2095
from bzrlib.revision import MultipleRevisionSources
2096
2097
branch1 = Branch.open_containing(branch)[0]
2098
branch2 = Branch.open_containing(other)[0]
2099
2100
history_1 = branch1.revision_history()
2101
history_2 = branch2.revision_history()
2102
2103
last1 = branch1.last_revision()
2104
last2 = branch2.last_revision()
2105
2106
source = MultipleRevisionSources(branch1.repository,
2107
branch2.repository)
2108
2109
base_rev_id = common_ancestor(last1, last2, source)
2110
2111
print 'merge base is revision %s' % base_rev_id
2112
2113
2114
class cmd_merge(Command):
2115
"""Perform a three-way merge.
2116
2117
The branch is the branch you will merge from. By default, it will merge
2118
the latest revision. If you specify a revision, that revision will be
2119
merged. If you specify two revisions, the first will be used as a BASE,
2120
and the second one as OTHER. Revision numbers are always relative to the
2121
specified branch.
2122
2123
By default, bzr will try to merge in all new work from the other
2124
branch, automatically determining an appropriate base. If this
2125
fails, you may need to give an explicit base.
2126
2127
Merge will do its best to combine the changes in two branches, but there
2128
are some kinds of problems only a human can fix. When it encounters those,
2129
it will mark a conflict. A conflict means that you need to fix something,
2130
before you should commit.
2131
2132
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2133
2134
If there is no default branch set, the first merge will set it. After
2135
that, you can omit the branch to use the default. To change the
2136
default, use --remember. The value will only be saved if the remote
2137
location can be accessed.
2138
2139
Examples:
2140
2141
To merge the latest revision from bzr.dev
2142
bzr merge ../bzr.dev
2143
2144
To merge changes up to and including revision 82 from bzr.dev
2145
bzr merge -r 82 ../bzr.dev
2146
2147
To merge the changes introduced by 82, without previous changes:
2148
bzr merge -r 81..82 ../bzr.dev
2149
2150
merge refuses to run if there are any uncommitted changes, unless
2151
--force is given.
2152
2153
The following merge types are available:
2154
"""
2155
takes_args = ['branch?']
2156
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2157
Option('show-base', help="Show base revision text in "
2158
"conflicts"),
2159
Option('uncommitted', help='Apply uncommitted changes'
2160
' from a working copy, instead of branch changes')]
2161
2162
def help(self):
2163
from inspect import getdoc
2164
return getdoc(self) + '\n' + _mod_merge.merge_type_help()
2165
2166
def run(self, branch=None, revision=None, force=False, merge_type=None,
2167
show_base=False, reprocess=False, remember=False,
2168
uncommitted=False):
2169
if merge_type is None:
2170
merge_type = _mod_merge.Merge3Merger
2171
2172
tree = WorkingTree.open_containing(u'.')[0]
2173
2174
if branch is not None:
2175
try:
2176
reader = bundle.read_bundle_from_url(branch)
2177
except errors.NotABundle:
2178
pass # Continue on considering this url a Branch
2179
else:
2180
conflicts = merge_bundle(reader, tree, not force, merge_type,
2181
reprocess, show_base)
2182
if conflicts == 0:
2183
return 0
2184
else:
2185
return 1
2186
2187
if revision is None \
2188
or len(revision) < 1 or revision[0].needs_branch():
2189
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2190
2191
if revision is None or len(revision) < 1:
2192
if uncommitted:
2193
base = [branch, -1]
2194
other = [branch, None]
2195
else:
2196
base = [None, None]
2197
other = [branch, -1]
2198
other_branch, path = Branch.open_containing(branch)
2199
else:
2200
if uncommitted:
2201
raise errors.BzrCommandError('Cannot use --uncommitted and'
2202
' --revision at the same time.')
2203
branch = revision[0].get_branch() or branch
2204
if len(revision) == 1:
2205
base = [None, None]
2206
other_branch, path = Branch.open_containing(branch)
2207
revno = revision[0].in_history(other_branch).revno
2208
other = [branch, revno]
2209
else:
2210
assert len(revision) == 2
2211
if None in revision:
2212
raise errors.BzrCommandError(
2213
"Merge doesn't permit empty revision specifier.")
2214
base_branch, path = Branch.open_containing(branch)
2215
branch1 = revision[1].get_branch() or branch
2216
other_branch, path1 = Branch.open_containing(branch1)
2217
if revision[0].get_branch() is not None:
2218
# then path was obtained from it, and is None.
2219
path = path1
2220
2221
base = [branch, revision[0].in_history(base_branch).revno]
2222
other = [branch1, revision[1].in_history(other_branch).revno]
2223
2224
if tree.branch.get_parent() is None or remember:
2225
tree.branch.set_parent(other_branch.base)
2226
2227
if path != "":
2228
interesting_files = [path]
2229
else:
2230
interesting_files = None
2231
pb = ui.ui_factory.nested_progress_bar()
2232
try:
2233
try:
2234
conflict_count = _merge_helper(
2235
other, base, check_clean=(not force),
2236
merge_type=merge_type,
2237
reprocess=reprocess,
2238
show_base=show_base,
2239
pb=pb, file_list=interesting_files)
2240
finally:
2241
pb.finished()
2242
if conflict_count != 0:
2243
return 1
2244
else:
2245
return 0
2246
except errors.AmbiguousBase, e:
2247
m = ("sorry, bzr can't determine the right merge base yet\n"
2248
"candidates are:\n "
2249
+ "\n ".join(e.bases)
2250
+ "\n"
2251
"please specify an explicit base with -r,\n"
2252
"and (if you want) report this to the bzr developers\n")
2253
log_error(m)
2254
2255
# TODO: move up to common parent; this isn't merge-specific anymore.
2256
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2257
"""Use tree.branch's parent if none was supplied.
2258
2259
Report if the remembered location was used.
2260
"""
2261
if supplied_location is not None:
2262
return supplied_location
2263
stored_location = tree.branch.get_parent()
2264
mutter("%s", stored_location)
2265
if stored_location is None:
2266
raise errors.BzrCommandError("No location specified or remembered")
2267
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2268
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2269
return stored_location
2270
2271
2272
class cmd_remerge(Command):
2273
"""Redo a merge.
2274
2275
Use this if you want to try a different merge technique while resolving
2276
conflicts. Some merge techniques are better than others, and remerge
2277
lets you try different ones on different files.
2278
2279
The options for remerge have the same meaning and defaults as the ones for
2280
merge. The difference is that remerge can (only) be run when there is a
2281
pending merge, and it lets you specify particular files.
2282
2283
Examples:
2284
$ bzr remerge --show-base
2285
Re-do the merge of all conflicted files, and show the base text in
2286
conflict regions, in addition to the usual THIS and OTHER texts.
2287
2288
$ bzr remerge --merge-type weave --reprocess foobar
2289
Re-do the merge of "foobar", using the weave merge algorithm, with
2290
additional processing to reduce the size of conflict regions.
2291
2292
The following merge types are available:"""
2293
takes_args = ['file*']
2294
takes_options = ['merge-type', 'reprocess',
2295
Option('show-base', help="Show base revision text in "
2296
"conflicts")]
2297
2298
def help(self):
2299
from inspect import getdoc
2300
return getdoc(self) + '\n' + _mod_merge.merge_type_help()
2301
2302
def run(self, file_list=None, merge_type=None, show_base=False,
2303
reprocess=False):
2304
if merge_type is None:
2305
merge_type = _mod_merge.Merge3Merger
2306
tree, file_list = tree_files(file_list)
2307
tree.lock_write()
2308
try:
2309
parents = tree.get_parent_ids()
2310
if len(parents) != 2:
2311
raise errors.BzrCommandError("Sorry, remerge only works after normal"
2312
" merges. Not cherrypicking or"
2313
" multi-merges.")
2314
repository = tree.branch.repository
2315
base_revision = common_ancestor(parents[0],
2316
parents[1], repository)
2317
base_tree = repository.revision_tree(base_revision)
2318
other_tree = repository.revision_tree(parents[1])
2319
interesting_ids = None
2320
new_conflicts = []
2321
conflicts = tree.conflicts()
2322
if file_list is not None:
2323
interesting_ids = set()
2324
for filename in file_list:
2325
file_id = tree.path2id(filename)
2326
if file_id is None:
2327
raise errors.NotVersionedError(filename)
2328
interesting_ids.add(file_id)
2329
if tree.kind(file_id) != "directory":
2330
continue
2331
2332
for name, ie in tree.inventory.iter_entries(file_id):
2333
interesting_ids.add(ie.file_id)
2334
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2335
else:
2336
# Remerge only supports resolving contents conflicts
2337
allowed_conflicts = ('text conflict', 'contents conflict')
2338
restore_files = [c.path for c in conflicts
2339
if c.typestring in allowed_conflicts]
2340
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2341
tree.set_conflicts(ConflictList(new_conflicts))
2342
if file_list is not None:
2343
restore_files = file_list
2344
for filename in restore_files:
2345
try:
2346
restore(tree.abspath(filename))
2347
except errors.NotConflicted:
2348
pass
2349
conflicts = _mod_merge.merge_inner(
2350
tree.branch, other_tree, base_tree,
2351
this_tree=tree,
2352
interesting_ids=interesting_ids,
2353
other_rev_id=parents[1],
2354
merge_type=merge_type,
2355
show_base=show_base,
2356
reprocess=reprocess)
2357
finally:
2358
tree.unlock()
2359
if conflicts > 0:
2360
return 1
2361
else:
2362
return 0
2363
2364
class cmd_revert(Command):
2365
"""Revert files to a previous revision.
2366
2367
Giving a list of files will revert only those files. Otherwise, all files
2368
will be reverted. If the revision is not specified with '--revision', the
2369
last committed revision is used.
2370
2371
To remove only some changes, without reverting to a prior version, use
2372
merge instead. For example, "merge . --r-2..-3" will remove the changes
2373
introduced by -2, without affecting the changes introduced by -1. Or
2374
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2375
2376
By default, any files that have been manually changed will be backed up
2377
first. (Files changed only by merge are not backed up.) Backup files have
2378
'.~#~' appended to their name, where # is a number.
2379
2380
When you provide files, you can use their current pathname or the pathname
2381
from the target revision. So you can use revert to "undelete" a file by
2382
name. If you name a directory, all the contents of that directory will be
2383
reverted.
2384
"""
2385
takes_options = ['revision', 'no-backup']
2386
takes_args = ['file*']
2387
aliases = ['merge-revert']
2388
2389
def run(self, revision=None, no_backup=False, file_list=None):
2390
if file_list is not None:
2391
if len(file_list) == 0:
2392
raise errors.BzrCommandError("No files specified")
2393
else:
2394
file_list = []
2395
2396
tree, file_list = tree_files(file_list)
2397
if revision is None:
2398
# FIXME should be tree.last_revision
2399
rev_id = tree.last_revision()
2400
elif len(revision) != 1:
2401
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
2402
else:
2403
rev_id = revision[0].in_history(tree.branch).rev_id
2404
pb = ui.ui_factory.nested_progress_bar()
2405
try:
2406
tree.revert(file_list,
2407
tree.branch.repository.revision_tree(rev_id),
2408
not no_backup, pb)
2409
finally:
2410
pb.finished()
2411
2412
2413
class cmd_assert_fail(Command):
2414
"""Test reporting of assertion failures"""
2415
hidden = True
2416
def run(self):
2417
assert False, "always fails"
2418
2419
2420
class cmd_help(Command):
2421
"""Show help on a command or other topic.
2422
2423
For a list of all available commands, say 'bzr help commands'."""
2424
takes_options = [Option('long', 'show help on all commands')]
2425
takes_args = ['topic?']
2426
aliases = ['?', '--help', '-?', '-h']
2427
2428
@display_command
2429
def run(self, topic=None, long=False):
2430
import help
2431
if topic is None and long:
2432
topic = "commands"
2433
help.help(topic)
2434
2435
2436
class cmd_shell_complete(Command):
2437
"""Show appropriate completions for context.
2438
2439
For a list of all available commands, say 'bzr shell-complete'."""
2440
takes_args = ['context?']
2441
aliases = ['s-c']
2442
hidden = True
2443
2444
@display_command
2445
def run(self, context=None):
2446
import shellcomplete
2447
shellcomplete.shellcomplete(context)
2448
2449
2450
class cmd_fetch(Command):
2451
"""Copy in history from another branch but don't merge it.
2452
2453
This is an internal method used for pull and merge."""
2454
hidden = True
2455
takes_args = ['from_branch', 'to_branch']
2456
def run(self, from_branch, to_branch):
2457
from bzrlib.fetch import Fetcher
2458
from_b = Branch.open(from_branch)
2459
to_b = Branch.open(to_branch)
2460
Fetcher(to_b, from_b)
2461
2462
2463
class cmd_missing(Command):
2464
"""Show unmerged/unpulled revisions between two branches.
2465
2466
OTHER_BRANCH may be local or remote."""
2467
takes_args = ['other_branch?']
2468
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2469
Option('mine-only',
2470
'Display changes in the local branch only'),
2471
Option('theirs-only',
2472
'Display changes in the remote branch only'),
2473
'log-format',
2474
'line',
2475
'long',
2476
'short',
2477
'show-ids',
2478
'verbose'
2479
]
2480
encoding_type = 'replace'
2481
2482
@display_command
2483
def run(self, other_branch=None, reverse=False, mine_only=False,
2484
theirs_only=False, log_format=None, long=False, short=False, line=False,
2485
show_ids=False, verbose=False):
2486
from bzrlib.missing import find_unmerged, iter_log_data
2487
from bzrlib.log import log_formatter
2488
local_branch = Branch.open_containing(u".")[0]
2489
parent = local_branch.get_parent()
2490
if other_branch is None:
2491
other_branch = parent
2492
if other_branch is None:
2493
raise errors.BzrCommandError("No peer location known or specified.")
2494
print "Using last location: " + local_branch.get_parent()
2495
remote_branch = Branch.open(other_branch)
2496
if remote_branch.base == local_branch.base:
2497
remote_branch = local_branch
2498
local_branch.lock_read()
2499
try:
2500
remote_branch.lock_read()
2501
try:
2502
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2503
if (log_format is None):
2504
default = local_branch.get_config().log_format()
2505
log_format = get_log_format(long=long, short=short,
2506
line=line, default=default)
2507
lf = log_formatter(log_format,
2508
to_file=self.outf,
2509
show_ids=show_ids,
2510
show_timezone='original')
2511
if reverse is False:
2512
local_extra.reverse()
2513
remote_extra.reverse()
2514
if local_extra and not theirs_only:
2515
print "You have %d extra revision(s):" % len(local_extra)
2516
for data in iter_log_data(local_extra, local_branch.repository,
2517
verbose):
2518
lf.show(*data)
2519
printed_local = True
2520
else:
2521
printed_local = False
2522
if remote_extra and not mine_only:
2523
if printed_local is True:
2524
print "\n\n"
2525
print "You are missing %d revision(s):" % len(remote_extra)
2526
for data in iter_log_data(remote_extra, remote_branch.repository,
2527
verbose):
2528
lf.show(*data)
2529
if not remote_extra and not local_extra:
2530
status_code = 0
2531
print "Branches are up to date."
2532
else:
2533
status_code = 1
2534
finally:
2535
remote_branch.unlock()
2536
finally:
2537
local_branch.unlock()
2538
if not status_code and parent is None and other_branch is not None:
2539
local_branch.lock_write()
2540
try:
2541
# handle race conditions - a parent might be set while we run.
2542
if local_branch.get_parent() is None:
2543
local_branch.set_parent(remote_branch.base)
2544
finally:
2545
local_branch.unlock()
2546
return status_code
2547
2548
2549
class cmd_plugins(Command):
2550
"""List plugins"""
2551
hidden = True
2552
@display_command
2553
def run(self):
2554
import bzrlib.plugin
2555
from inspect import getdoc
2556
for name, plugin in bzrlib.plugin.all_plugins().items():
2557
if getattr(plugin, '__path__', None) is not None:
2558
print plugin.__path__[0]
2559
elif getattr(plugin, '__file__', None) is not None:
2560
print plugin.__file__
2561
else:
2562
print repr(plugin)
2563
2564
d = getdoc(plugin)
2565
if d:
2566
print '\t', d.split('\n')[0]
2567
2568
2569
class cmd_testament(Command):
2570
"""Show testament (signing-form) of a revision."""
2571
takes_options = ['revision',
2572
Option('long', help='Produce long-format testament'),
2573
Option('strict', help='Produce a strict-format'
2574
' testament')]
2575
takes_args = ['branch?']
2576
@display_command
2577
def run(self, branch=u'.', revision=None, long=False, strict=False):
2578
from bzrlib.testament import Testament, StrictTestament
2579
if strict is True:
2580
testament_class = StrictTestament
2581
else:
2582
testament_class = Testament
2583
b = WorkingTree.open_containing(branch)[0].branch
2584
b.lock_read()
2585
try:
2586
if revision is None:
2587
rev_id = b.last_revision()
2588
else:
2589
rev_id = revision[0].in_history(b).rev_id
2590
t = testament_class.from_revision(b.repository, rev_id)
2591
if long:
2592
sys.stdout.writelines(t.as_text_lines())
2593
else:
2594
sys.stdout.write(t.as_short_text())
2595
finally:
2596
b.unlock()
2597
2598
2599
class cmd_annotate(Command):
2600
"""Show the origin of each line in a file.
2601
2602
This prints out the given file with an annotation on the left side
2603
indicating which revision, author and date introduced the change.
2604
2605
If the origin is the same for a run of consecutive lines, it is
2606
shown only at the top, unless the --all option is given.
2607
"""
2608
# TODO: annotate directories; showing when each file was last changed
2609
# TODO: if the working copy is modified, show annotations on that
2610
# with new uncommitted lines marked
2611
aliases = ['ann', 'blame', 'praise']
2612
takes_args = ['filename']
2613
takes_options = [Option('all', help='show annotations on all lines'),
2614
Option('long', help='show date in annotations'),
2615
'revision'
2616
]
2617
2618
@display_command
2619
def run(self, filename, all=False, long=False, revision=None):
2620
from bzrlib.annotate import annotate_file
2621
tree, relpath = WorkingTree.open_containing(filename)
2622
branch = tree.branch
2623
branch.lock_read()
2624
try:
2625
if revision is None:
2626
revision_id = branch.last_revision()
2627
elif len(revision) != 1:
2628
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2629
else:
2630
revision_id = revision[0].in_history(branch).rev_id
2631
file_id = tree.inventory.path2id(relpath)
2632
tree = branch.repository.revision_tree(revision_id)
2633
file_version = tree.inventory[file_id].revision
2634
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2635
finally:
2636
branch.unlock()
2637
2638
2639
class cmd_re_sign(Command):
2640
"""Create a digital signature for an existing revision."""
2641
# TODO be able to replace existing ones.
2642
2643
hidden = True # is this right ?
2644
takes_args = ['revision_id*']
2645
takes_options = ['revision']
2646
2647
def run(self, revision_id_list=None, revision=None):
2648
import bzrlib.gpg as gpg
2649
if revision_id_list is not None and revision is not None:
2650
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
2651
if revision_id_list is None and revision is None:
2652
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
2653
b = WorkingTree.open_containing(u'.')[0].branch
2654
gpg_strategy = gpg.GPGStrategy(b.get_config())
2655
if revision_id_list is not None:
2656
for revision_id in revision_id_list:
2657
b.repository.sign_revision(revision_id, gpg_strategy)
2658
elif revision is not None:
2659
if len(revision) == 1:
2660
revno, rev_id = revision[0].in_history(b)
2661
b.repository.sign_revision(rev_id, gpg_strategy)
2662
elif len(revision) == 2:
2663
# are they both on rh- if so we can walk between them
2664
# might be nice to have a range helper for arbitrary
2665
# revision paths. hmm.
2666
from_revno, from_revid = revision[0].in_history(b)
2667
to_revno, to_revid = revision[1].in_history(b)
2668
if to_revid is None:
2669
to_revno = b.revno()
2670
if from_revno is None or to_revno is None:
2671
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
2672
for revno in range(from_revno, to_revno + 1):
2673
b.repository.sign_revision(b.get_rev_id(revno),
2674
gpg_strategy)
2675
else:
2676
raise errors.BzrCommandError('Please supply either one revision, or a range.')
2677
2678
2679
class cmd_bind(Command):
2680
"""Bind the current branch to a master branch.
2681
2682
After binding, commits must succeed on the master branch
2683
before they are executed on the local one.
2684
"""
2685
2686
takes_args = ['location']
2687
takes_options = []
2688
2689
def run(self, location=None):
2690
b, relpath = Branch.open_containing(u'.')
2691
b_other = Branch.open(location)
2692
try:
2693
b.bind(b_other)
2694
except errors.DivergedBranches:
2695
raise errors.BzrCommandError('These branches have diverged.'
2696
' Try merging, and then bind again.')
2697
2698
2699
class cmd_unbind(Command):
2700
"""Unbind the current branch from its master branch.
2701
2702
After unbinding, the local branch is considered independent.
2703
All subsequent commits will be local.
2704
"""
2705
2706
takes_args = []
2707
takes_options = []
2708
2709
def run(self):
2710
b, relpath = Branch.open_containing(u'.')
2711
if not b.unbind():
2712
raise errors.BzrCommandError('Local branch is not bound')
2713
2714
2715
class cmd_uncommit(Command):
2716
"""Remove the last committed revision.
2717
2718
--verbose will print out what is being removed.
2719
--dry-run will go through all the motions, but not actually
2720
remove anything.
2721
2722
In the future, uncommit will create a revision bundle, which can then
2723
be re-applied.
2724
"""
2725
2726
# TODO: jam 20060108 Add an option to allow uncommit to remove
2727
# unreferenced information in 'branch-as-repository' branches.
2728
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2729
# information in shared branches as well.
2730
takes_options = ['verbose', 'revision',
2731
Option('dry-run', help='Don\'t actually make changes'),
2732
Option('force', help='Say yes to all questions.')]
2733
takes_args = ['location?']
2734
aliases = []
2735
2736
def run(self, location=None,
2737
dry_run=False, verbose=False,
2738
revision=None, force=False):
2739
from bzrlib.log import log_formatter, show_log
2740
import sys
2741
from bzrlib.uncommit import uncommit
2742
2743
if location is None:
2744
location = u'.'
2745
control, relpath = bzrdir.BzrDir.open_containing(location)
2746
try:
2747
tree = control.open_workingtree()
2748
b = tree.branch
2749
except (errors.NoWorkingTree, errors.NotLocalUrl):
2750
tree = None
2751
b = control.open_branch()
2752
2753
rev_id = None
2754
if revision is None:
2755
revno = b.revno()
2756
else:
2757
# 'bzr uncommit -r 10' actually means uncommit
2758
# so that the final tree is at revno 10.
2759
# but bzrlib.uncommit.uncommit() actually uncommits
2760
# the revisions that are supplied.
2761
# So we need to offset it by one
2762
revno = revision[0].in_history(b).revno+1
2763
2764
if revno <= b.revno():
2765
rev_id = b.get_rev_id(revno)
2766
if rev_id is None:
2767
self.outf.write('No revisions to uncommit.\n')
2768
return 1
2769
2770
lf = log_formatter('short',
2771
to_file=self.outf,
2772
show_timezone='original')
2773
2774
show_log(b,
2775
lf,
2776
verbose=False,
2777
direction='forward',
2778
start_revision=revno,
2779
end_revision=b.revno())
2780
2781
if dry_run:
2782
print 'Dry-run, pretending to remove the above revisions.'
2783
if not force:
2784
val = raw_input('Press <enter> to continue')
2785
else:
2786
print 'The above revision(s) will be removed.'
2787
if not force:
2788
val = raw_input('Are you sure [y/N]? ')
2789
if val.lower() not in ('y', 'yes'):
2790
print 'Canceled'
2791
return 0
2792
2793
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2794
revno=revno)
2795
2796
2797
class cmd_break_lock(Command):
2798
"""Break a dead lock on a repository, branch or working directory.
2799
2800
CAUTION: Locks should only be broken when you are sure that the process
2801
holding the lock has been stopped.
2802
2803
You can get information on what locks are open via the 'bzr info' command.
2804
2805
example:
2806
bzr break-lock
2807
"""
2808
takes_args = ['location?']
2809
2810
def run(self, location=None, show=False):
2811
if location is None:
2812
location = u'.'
2813
control, relpath = bzrdir.BzrDir.open_containing(location)
2814
try:
2815
control.break_lock()
2816
except NotImplementedError:
2817
pass
2818
2819
2820
class cmd_wait_until_signalled(Command):
2821
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
2822
2823
This just prints a line to signal when it is ready, then blocks on stdin.
2824
"""
2825
2826
hidden = True
2827
2828
def run(self):
2829
sys.stdout.write("running\n")
2830
sys.stdout.flush()
2831
sys.stdin.readline()
2832
2833
2834
class cmd_serve(Command):
2835
"""Run the bzr server."""
2836
2837
aliases = ['server']
2838
2839
takes_options = [
2840
Option('inet',
2841
help='serve on stdin/out for use from inetd or sshd'),
2842
Option('port',
2843
help='listen for connections on nominated port of the form '
2844
'[hostname:]portnumber. Passing 0 as the port number will '
2845
'result in a dynamically allocated port.',
2846
type=str),
2847
Option('directory',
2848
help='serve contents of directory',
2849
type=unicode),
2850
Option('allow-writes',
2851
help='By default the server is a readonly server. Supplying '
2852
'--allow-writes enables write access to the contents of '
2853
'the served directory and below. '
2854
),
2855
]
2856
2857
def run(self, port=None, inet=False, directory=None, allow_writes=False):
2858
from bzrlib.transport import smart
2859
from bzrlib.transport import get_transport
2860
if directory is None:
2861
directory = os.getcwd()
2862
url = urlutils.local_path_to_url(directory)
2863
if not allow_writes:
2864
url = 'readonly+' + url
2865
t = get_transport(url)
2866
if inet:
2867
server = smart.SmartServerPipeStreamMedium(sys.stdin, sys.stdout, t)
2868
elif port is not None:
2869
if ':' in port:
2870
host, port = port.split(':')
2871
else:
2872
host = '127.0.0.1'
2873
server = smart.SmartTCPServer(t, host=host, port=int(port))
2874
print 'listening on port: ', server.port
2875
sys.stdout.flush()
2876
else:
2877
raise errors.BzrCommandError("bzr serve requires one of --inet or --port")
2878
server.serve()
2879
2880
2881
# command-line interpretation helper for merge-related commands
2882
def _merge_helper(other_revision, base_revision,
2883
check_clean=True, ignore_zero=False,
2884
this_dir=None, backup_files=False,
2885
merge_type=None,
2886
file_list=None, show_base=False, reprocess=False,
2887
pb=DummyProgress()):
2888
"""Merge changes into a tree.
2889
2890
base_revision
2891
list(path, revno) Base for three-way merge.
2892
If [None, None] then a base will be automatically determined.
2893
other_revision
2894
list(path, revno) Other revision for three-way merge.
2895
this_dir
2896
Directory to merge changes into; '.' by default.
2897
check_clean
2898
If true, this_dir must have no uncommitted changes before the
2899
merge begins.
2900
ignore_zero - If true, suppress the "zero conflicts" message when
2901
there are no conflicts; should be set when doing something we expect
2902
to complete perfectly.
2903
file_list - If supplied, merge only changes to selected files.
2904
2905
All available ancestors of other_revision and base_revision are
2906
automatically pulled into the branch.
2907
2908
The revno may be -1 to indicate the last revision on the branch, which is
2909
the typical case.
2910
2911
This function is intended for use from the command line; programmatic
2912
clients might prefer to call merge.merge_inner(), which has less magic
2913
behavior.
2914
"""
2915
# Loading it late, so that we don't always have to import bzrlib.merge
2916
if merge_type is None:
2917
merge_type = _mod_merge.Merge3Merger
2918
if this_dir is None:
2919
this_dir = u'.'
2920
this_tree = WorkingTree.open_containing(this_dir)[0]
2921
if show_base and not merge_type is _mod_merge.Merge3Merger:
2922
raise errors.BzrCommandError("Show-base is not supported for this merge"
2923
" type. %s" % merge_type)
2924
if reprocess and not merge_type.supports_reprocess:
2925
raise errors.BzrCommandError("Conflict reduction is not supported for merge"
2926
" type %s." % merge_type)
2927
if reprocess and show_base:
2928
raise errors.BzrCommandError("Cannot do conflict reduction and show base.")
2929
try:
2930
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
2931
pb=pb)
2932
merger.pp = ProgressPhase("Merge phase", 5, pb)
2933
merger.pp.next_phase()
2934
merger.check_basis(check_clean)
2935
merger.set_other(other_revision)
2936
merger.pp.next_phase()
2937
merger.set_base(base_revision)
2938
if merger.base_rev_id == merger.other_rev_id:
2939
note('Nothing to do.')
2940
return 0
2941
merger.backup_files = backup_files
2942
merger.merge_type = merge_type
2943
merger.set_interesting_files(file_list)
2944
merger.show_base = show_base
2945
merger.reprocess = reprocess
2946
conflicts = merger.do_merge()
2947
if file_list is None:
2948
merger.set_pending()
2949
finally:
2950
pb.clear()
2951
return conflicts
2952
2953
2954
# Compatibility
2955
merge = _merge_helper
2956
2957
2958
# these get imported and then picked up by the scan for cmd_*
2959
# TODO: Some more consistent way to split command definitions across files;
2960
# we do need to load at least some information about them to know of
2961
# aliases. ideally we would avoid loading the implementation until the
2962
# details were needed.
2963
from bzrlib.cmd_version_info import cmd_version_info
2964
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2965
from bzrlib.bundle.commands import cmd_bundle_revisions
2966
from bzrlib.sign_my_commits import cmd_sign_my_commits
2967
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2968
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0