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