(root)/brz/remove-bazaar
» Revision
1731.1.56
(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 1731.1.56
- compare with another revision
- download diff
- download tarball
- view history from revision 1731.1.56
- Committer: Aaron Bentley
- Date: 2006-09-28 22:56:04 UTC
- mto: (1731.2.8 nested-trees)
- mto: This revision was merged to the branch mainline in revision 2078.
- Revision ID: aaron.bentley@utoronto.ca-20060928225604-415f1396ea1d2b97
Fix EmptyTree's default include_root
- 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
20
import codecs
21
import errno
22
import os
23
import os.path
24
import sys
25
26
import bzrlib
27
from bzrlib import (
28
branch,
29
bundle,
30
bzrdir,
31
config,
32
errors,
33
ignores,
34
log,
35
osutils,
36
repository,
37
transport,
38
ui,
39
urlutils,
40
)
41
from bzrlib.branch import Branch, BranchReferenceFormat
42
from bzrlib.bundle import read_bundle_from_url
43
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
44
from bzrlib.conflicts import ConflictList
45
from bzrlib.commands import Command, display_command
46
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
47
NotBranchError, DivergedBranches, NotConflicted,
48
NoSuchFile, NoWorkingTree, FileInWrongBranch,
49
NotVersionedError, NotABundle)
50
from bzrlib.merge import Merge3Merger
51
from bzrlib.option import Option
52
from bzrlib.progress import DummyProgress, ProgressPhase
53
from bzrlib.revision import common_ancestor
54
from bzrlib.revisionspec import RevisionSpec
55
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
56
from bzrlib.transport.local import LocalTransport
57
import bzrlib.tree
58
from bzrlib.workingtree import WorkingTree
59
60
61
def tree_files(file_list, default_branch=u'.'):
62
try:
63
return internal_tree_files(file_list, default_branch)
64
except FileInWrongBranch, e:
65
raise BzrCommandError("%s is not in the same branch as %s" %
66
(e.path, file_list[0]))
67
68
69
# XXX: Bad function name; should possibly also be a class method of
70
# WorkingTree rather than a function.
71
def internal_tree_files(file_list, default_branch=u'.'):
72
"""Convert command-line paths to a WorkingTree and relative paths.
73
74
This is typically used for command-line processors that take one or
75
more filenames, and infer the workingtree that contains them.
76
77
The filenames given are not required to exist.
78
79
:param file_list: Filenames to convert.
80
81
:param default_branch: Fallback tree path to use if file_list is empty or None.
82
83
:return: workingtree, [relative_paths]
84
"""
85
if file_list is None or len(file_list) == 0:
86
return WorkingTree.open_containing(default_branch)[0], file_list
87
tree = WorkingTree.open_containing(file_list[0])[0]
88
new_list = []
89
for filename in file_list:
90
try:
91
new_list.append(tree.relpath(filename))
92
except errors.PathNotChild:
93
raise FileInWrongBranch(tree.branch, filename)
94
return tree, new_list
95
96
97
def get_format_type(typestring):
98
"""Parse and return a format specifier."""
99
if typestring == "weave":
100
return bzrdir.BzrDirFormat6()
101
if typestring == "default":
102
return bzrdir.BzrDirMetaFormat1()
103
if typestring == "metaweave":
104
format = bzrdir.BzrDirMetaFormat1()
105
format.repository_format = repository.RepositoryFormat7()
106
return format
107
if typestring == "knit":
108
format = bzrdir.BzrDirMetaFormat1()
109
format.repository_format = repository.RepositoryFormatKnit1()
110
return format
111
if typestring == "experimental-knit2":
112
format = bzrdir.BzrDirMetaFormat1()
113
format.repository_format = repository.RepositoryFormatKnit2()
114
return format
115
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
116
"metaweave and weave" % typestring
117
raise BzrCommandError(msg)
118
119
120
# TODO: Make sure no commands unconditionally use the working directory as a
121
# branch. If a filename argument is used, the first of them should be used to
122
# specify the branch. (Perhaps this can be factored out into some kind of
123
# Argument class, representing a file in a branch, where the first occurrence
124
# opens the branch?)
125
126
class cmd_status(Command):
127
"""Display status summary.
128
129
This reports on versioned and unknown files, reporting them
130
grouped by state. Possible states are:
131
132
added
133
Versioned in the working copy but not in the previous revision.
134
135
removed
136
Versioned in the previous revision but removed or deleted
137
in the working copy.
138
139
renamed
140
Path of this file changed from the previous revision;
141
the text may also have changed. This includes files whose
142
parent directory was renamed.
143
144
modified
145
Text has changed since the previous revision.
146
147
unknown
148
Not versioned and not matching an ignore pattern.
149
150
To see ignored files use 'bzr ignored'. For details in the
151
changes to file texts, use 'bzr diff'.
152
153
If no arguments are specified, the status of the entire working
154
directory is shown. Otherwise, only the status of the specified
155
files or directories is reported. If a directory is given, status
156
is reported for everything inside that directory.
157
158
If a revision argument is given, the status is calculated against
159
that revision, or between two revisions if two are provided.
160
"""
161
162
# TODO: --no-recurse, --recurse options
163
164
takes_args = ['file*']
165
takes_options = ['show-ids', 'revision']
166
aliases = ['st', 'stat']
167
168
encoding_type = 'replace'
169
170
@display_command
171
def run(self, show_ids=False, file_list=None, revision=None):
172
from bzrlib.status import show_tree_status
173
174
tree, file_list = tree_files(file_list)
175
176
show_tree_status(tree, show_ids=show_ids,
177
specific_files=file_list, revision=revision,
178
to_file=self.outf)
179
180
181
class cmd_cat_revision(Command):
182
"""Write out metadata for a revision.
183
184
The revision to print can either be specified by a specific
185
revision identifier, or you can use --revision.
186
"""
187
188
hidden = True
189
takes_args = ['revision_id?']
190
takes_options = ['revision']
191
# cat-revision is more for frontends so should be exact
192
encoding = 'strict'
193
194
@display_command
195
def run(self, revision_id=None, revision=None):
196
197
if revision_id is not None and revision is not None:
198
raise BzrCommandError('You can only supply one of revision_id or --revision')
199
if revision_id is None and revision is None:
200
raise BzrCommandError('You must supply either --revision or a revision_id')
201
b = WorkingTree.open_containing(u'.')[0].branch
202
203
# TODO: jam 20060112 should cat-revision always output utf-8?
204
if revision_id is not None:
205
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
206
elif revision is not None:
207
for rev in revision:
208
if rev is None:
209
raise BzrCommandError('You cannot specify a NULL revision.')
210
revno, rev_id = rev.in_history(b)
211
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
212
213
214
class cmd_revno(Command):
215
"""Show current revision number.
216
217
This is equal to the number of revisions on this branch.
218
"""
219
220
takes_args = ['location?']
221
222
@display_command
223
def run(self, location=u'.'):
224
self.outf.write(str(Branch.open_containing(location)[0].revno()))
225
self.outf.write('\n')
226
227
228
class cmd_revision_info(Command):
229
"""Show revision number and revision id for a given revision identifier.
230
"""
231
hidden = True
232
takes_args = ['revision_info*']
233
takes_options = ['revision']
234
235
@display_command
236
def run(self, revision=None, revision_info_list=[]):
237
238
revs = []
239
if revision is not None:
240
revs.extend(revision)
241
if revision_info_list is not None:
242
for rev in revision_info_list:
243
revs.append(RevisionSpec.from_string(rev))
244
if len(revs) == 0:
245
raise BzrCommandError('You must supply a revision identifier')
246
247
b = WorkingTree.open_containing(u'.')[0].branch
248
249
for rev in revs:
250
revinfo = rev.in_history(b)
251
if revinfo.revno is None:
252
print ' %s' % revinfo.rev_id
253
else:
254
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
255
256
257
class cmd_add(Command):
258
"""Add specified files or directories.
259
260
In non-recursive mode, all the named items are added, regardless
261
of whether they were previously ignored. A warning is given if
262
any of the named files are already versioned.
263
264
In recursive mode (the default), files are treated the same way
265
but the behaviour for directories is different. Directories that
266
are already versioned do not give a warning. All directories,
267
whether already versioned or not, are searched for files or
268
subdirectories that are neither versioned or ignored, and these
269
are added. This search proceeds recursively into versioned
270
directories. If no names are given '.' is assumed.
271
272
Therefore simply saying 'bzr add' will version all files that
273
are currently unknown.
274
275
Adding a file whose parent directory is not versioned will
276
implicitly add the parent, and so on up to the root. This means
277
you should never need to explicitly add a directory, they'll just
278
get added when you add a file in the directory.
279
280
--dry-run will show which files would be added, but not actually
281
add them.
282
283
--file-ids-from will try to use the file ids from the supplied path.
284
It looks up ids trying to find a matching parent directory with the
285
same filename, and then by pure path.
286
"""
287
takes_args = ['file*']
288
takes_options = ['no-recurse', 'dry-run', 'verbose',
289
Option('file-ids-from', type=unicode,
290
help='Lookup file ids from here')]
291
encoding_type = 'replace'
292
293
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
294
file_ids_from=None):
295
import bzrlib.add
296
297
if file_ids_from is not None:
298
try:
299
base_tree, base_path = WorkingTree.open_containing(
300
file_ids_from)
301
except errors.NoWorkingTree:
302
base_branch, base_path = branch.Branch.open_containing(
303
file_ids_from)
304
base_tree = base_branch.basis_tree()
305
306
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
307
to_file=self.outf, should_print=(not is_quiet()))
308
else:
309
action = bzrlib.add.AddAction(to_file=self.outf,
310
should_print=(not is_quiet()))
311
312
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
313
action=action, save=not dry_run)
314
if len(ignored) > 0:
315
if verbose:
316
for glob in sorted(ignored.keys()):
317
for path in ignored[glob]:
318
self.outf.write("ignored %s matching \"%s\"\n"
319
% (path, glob))
320
else:
321
match_len = 0
322
for glob, paths in ignored.items():
323
match_len += len(paths)
324
self.outf.write("ignored %d file(s).\n" % match_len)
325
self.outf.write("If you wish to add some of these files,"
326
" please add them by name.\n")
327
328
329
class cmd_mkdir(Command):
330
"""Create a new versioned directory.
331
332
This is equivalent to creating the directory and then adding it.
333
"""
334
335
takes_args = ['dir+']
336
encoding_type = 'replace'
337
338
def run(self, dir_list):
339
for d in dir_list:
340
os.mkdir(d)
341
wt, dd = WorkingTree.open_containing(d)
342
wt.add([dd])
343
self.outf.write('added %s\n' % d)
344
345
346
class cmd_relpath(Command):
347
"""Show path of a file relative to root"""
348
349
takes_args = ['filename']
350
hidden = True
351
352
@display_command
353
def run(self, filename):
354
# TODO: jam 20050106 Can relpath return a munged path if
355
# sys.stdout encoding cannot represent it?
356
tree, relpath = WorkingTree.open_containing(filename)
357
self.outf.write(relpath)
358
self.outf.write('\n')
359
360
361
class cmd_inventory(Command):
362
"""Show inventory of the current working copy or a revision.
363
364
It is possible to limit the output to a particular entry
365
type using the --kind option. For example: --kind file.
366
367
It is also possible to restrict the list of files to a specific
368
set. For example: bzr inventory --show-ids this/file
369
"""
370
371
takes_options = ['revision', 'show-ids', 'kind']
372
takes_args = ['file*']
373
374
@display_command
375
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
376
if kind and kind not in ['file', 'directory', 'symlink']:
377
raise BzrCommandError('invalid kind specified')
378
379
work_tree, file_list = tree_files(file_list)
380
381
if revision is not None:
382
if len(revision) > 1:
383
raise BzrCommandError('bzr inventory --revision takes'
384
' exactly one revision identifier')
385
revision_id = revision[0].in_history(work_tree.branch).rev_id
386
tree = work_tree.branch.repository.revision_tree(revision_id)
387
388
# We include work_tree as well as 'tree' here
389
# So that doing '-r 10 path/foo' will lookup whatever file
390
# exists now at 'path/foo' even if it has been renamed, as
391
# well as whatever files existed in revision 10 at path/foo
392
trees = [tree, work_tree]
393
else:
394
tree = work_tree
395
trees = [tree]
396
397
if file_list is not None:
398
file_ids = bzrlib.tree.find_ids_across_trees(file_list, trees,
399
require_versioned=True)
400
# find_ids_across_trees may include some paths that don't
401
# exist in 'tree'.
402
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
403
for file_id in file_ids if file_id in tree)
404
else:
405
entries = tree.inventory.entries()
406
407
for path, entry in entries:
408
if kind and kind != entry.kind:
409
continue
410
if show_ids:
411
self.outf.write('%-50s %s\n' % (path, entry.file_id))
412
else:
413
self.outf.write(path)
414
self.outf.write('\n')
415
416
417
class cmd_mv(Command):
418
"""Move or rename a file.
419
420
usage:
421
bzr mv OLDNAME NEWNAME
422
bzr mv SOURCE... DESTINATION
423
424
If the last argument is a versioned directory, all the other names
425
are moved into it. Otherwise, there must be exactly two arguments
426
and the file is changed to a new name, which must not already exist.
427
428
Files cannot be moved between branches.
429
"""
430
431
takes_args = ['names*']
432
aliases = ['move', 'rename']
433
encoding_type = 'replace'
434
435
def run(self, names_list):
436
if names_list is None:
437
names_list = []
438
439
if len(names_list) < 2:
440
raise BzrCommandError("missing file argument")
441
tree, rel_names = tree_files(names_list)
442
443
if os.path.isdir(names_list[-1]):
444
# move into existing directory
445
for pair in tree.move(rel_names[:-1], rel_names[-1]):
446
self.outf.write("%s => %s\n" % pair)
447
else:
448
if len(names_list) != 2:
449
raise BzrCommandError('to mv multiple files the destination '
450
'must be a versioned directory')
451
tree.rename_one(rel_names[0], rel_names[1])
452
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
453
454
455
class cmd_pull(Command):
456
"""Turn this branch into a mirror of another branch.
457
458
This command only works on branches that have not diverged. Branches are
459
considered diverged if the destination branch's most recent commit is one
460
that has not been merged (directly or indirectly) into the parent.
461
462
If branches have diverged, you can use 'bzr merge' to integrate the changes
463
from one into the other. Once one branch has merged, the other should
464
be able to pull it again.
465
466
If you want to forget your local changes and just update your branch to
467
match the remote one, use pull --overwrite.
468
469
If there is no default location set, the first pull will set it. After
470
that, you can omit the location to use the default. To change the
471
default, use --remember. The value will only be saved if the remote
472
location can be accessed.
473
"""
474
475
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
476
takes_args = ['location?']
477
encoding_type = 'replace'
478
479
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
480
# FIXME: too much stuff is in the command class
481
try:
482
tree_to = WorkingTree.open_containing(u'.')[0]
483
branch_to = tree_to.branch
484
except NoWorkingTree:
485
tree_to = None
486
branch_to = Branch.open_containing(u'.')[0]
487
488
reader = None
489
if location is not None:
490
try:
491
reader = bundle.read_bundle_from_url(location)
492
except NotABundle:
493
pass # Continue on considering this url a Branch
494
495
stored_loc = branch_to.get_parent()
496
if location is None:
497
if stored_loc is None:
498
raise BzrCommandError("No pull location known or specified.")
499
else:
500
display_url = urlutils.unescape_for_display(stored_loc,
501
self.outf.encoding)
502
self.outf.write("Using saved location: %s\n" % display_url)
503
location = stored_loc
504
505
506
if reader is not None:
507
install_bundle(branch_to.repository, reader)
508
branch_from = branch_to
509
else:
510
branch_from = Branch.open(location)
511
512
if branch_to.get_parent() is None or remember:
513
branch_to.set_parent(branch_from.base)
514
515
rev_id = None
516
if revision is None:
517
if reader is not None:
518
rev_id = reader.target
519
elif len(revision) == 1:
520
rev_id = revision[0].in_history(branch_from).rev_id
521
else:
522
raise BzrCommandError('bzr pull --revision takes one value.')
523
524
old_rh = branch_to.revision_history()
525
if tree_to is not None:
526
count = tree_to.pull(branch_from, overwrite, rev_id)
527
else:
528
count = branch_to.pull(branch_from, overwrite, rev_id)
529
note('%d revision(s) pulled.' % (count,))
530
531
if verbose:
532
new_rh = branch_to.revision_history()
533
if old_rh != new_rh:
534
# Something changed
535
from bzrlib.log import show_changed_revisions
536
show_changed_revisions(branch_to, old_rh, new_rh,
537
to_file=self.outf)
538
539
540
class cmd_push(Command):
541
"""Update a mirror of this branch.
542
543
The target branch will not have its working tree populated because this
544
is both expensive, and is not supported on remote file systems.
545
546
Some smart servers or protocols *may* put the working tree in place in
547
the future.
548
549
This command only works on branches that have not diverged. Branches are
550
considered diverged if the destination branch's most recent commit is one
551
that has not been merged (directly or indirectly) by the source branch.
552
553
If branches have diverged, you can use 'bzr push --overwrite' to replace
554
the other branch completely, discarding its unmerged changes.
555
556
If you want to ensure you have the different changes in the other branch,
557
do a merge (see bzr help merge) from the other branch, and commit that.
558
After that you will be able to do a push without '--overwrite'.
559
560
If there is no default push location set, the first push will set it.
561
After that, you can omit the location to use the default. To change the
562
default, use --remember. The value will only be saved if the remote
563
location can be accessed.
564
"""
565
566
takes_options = ['remember', 'overwrite', 'verbose',
567
Option('create-prefix',
568
help='Create the path leading up to the branch '
569
'if it does not already exist')]
570
takes_args = ['location?']
571
encoding_type = 'replace'
572
573
def run(self, location=None, remember=False, overwrite=False,
574
create_prefix=False, verbose=False):
575
# FIXME: Way too big! Put this into a function called from the
576
# command.
577
578
br_from = Branch.open_containing('.')[0]
579
stored_loc = br_from.get_push_location()
580
if location is None:
581
if stored_loc is None:
582
raise BzrCommandError("No push location known or specified.")
583
else:
584
display_url = urlutils.unescape_for_display(stored_loc,
585
self.outf.encoding)
586
self.outf.write("Using saved location: %s\n" % display_url)
587
location = stored_loc
588
589
to_transport = transport.get_transport(location)
590
location_url = to_transport.base
591
592
old_rh = []
593
try:
594
dir_to = bzrdir.BzrDir.open(location_url)
595
br_to = dir_to.open_branch()
596
except NotBranchError:
597
# create a branch.
598
to_transport = to_transport.clone('..')
599
if not create_prefix:
600
try:
601
relurl = to_transport.relpath(location_url)
602
mutter('creating directory %s => %s', location_url, relurl)
603
to_transport.mkdir(relurl)
604
except NoSuchFile:
605
raise BzrCommandError("Parent directory of %s "
606
"does not exist." % location)
607
else:
608
current = to_transport.base
609
needed = [(to_transport, to_transport.relpath(location_url))]
610
while needed:
611
try:
612
to_transport, relpath = needed[-1]
613
to_transport.mkdir(relpath)
614
needed.pop()
615
except NoSuchFile:
616
new_transport = to_transport.clone('..')
617
needed.append((new_transport,
618
new_transport.relpath(to_transport.base)))
619
if new_transport.base == to_transport.base:
620
raise BzrCommandError("Could not create "
621
"path prefix.")
622
dir_to = br_from.bzrdir.clone(location_url,
623
revision_id=br_from.last_revision())
624
br_to = dir_to.open_branch()
625
count = len(br_to.revision_history())
626
# We successfully created the target, remember it
627
if br_from.get_push_location() is None or remember:
628
br_from.set_push_location(br_to.base)
629
else:
630
# We were able to connect to the remote location, so remember it
631
# we don't need to successfully push because of possible divergence.
632
if br_from.get_push_location() is None or remember:
633
br_from.set_push_location(br_to.base)
634
old_rh = br_to.revision_history()
635
try:
636
try:
637
tree_to = dir_to.open_workingtree()
638
except errors.NotLocalUrl:
639
warning('This transport does not update the working '
640
'tree of: %s' % (br_to.base,))
641
count = br_to.pull(br_from, overwrite)
642
except NoWorkingTree:
643
count = br_to.pull(br_from, overwrite)
644
else:
645
count = tree_to.pull(br_from, overwrite)
646
except DivergedBranches:
647
raise BzrCommandError("These branches have diverged."
648
" Try a merge then push with overwrite.")
649
note('%d revision(s) pushed.' % (count,))
650
651
if verbose:
652
new_rh = br_to.revision_history()
653
if old_rh != new_rh:
654
# Something changed
655
from bzrlib.log import show_changed_revisions
656
show_changed_revisions(br_to, old_rh, new_rh,
657
to_file=self.outf)
658
659
660
class cmd_branch(Command):
661
"""Create a new copy of a branch.
662
663
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
664
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
665
666
To retrieve the branch as of a particular revision, supply the --revision
667
parameter, as in "branch foo/bar -r 5".
668
669
--basis is to speed up branching from remote branches. When specified, it
670
copies all the file-contents, inventory and revision data from the basis
671
branch before copying anything from the remote branch.
672
"""
673
takes_args = ['from_location', 'to_location?']
674
takes_options = ['revision', 'basis']
675
aliases = ['get', 'clone']
676
677
def run(self, from_location, to_location=None, revision=None, basis=None):
678
if revision is None:
679
revision = [None]
680
elif len(revision) > 1:
681
raise BzrCommandError(
682
'bzr branch --revision takes exactly 1 revision value')
683
try:
684
br_from = Branch.open(from_location)
685
except OSError, e:
686
if e.errno == errno.ENOENT:
687
raise BzrCommandError('Source location "%s" does not'
688
' exist.' % to_location)
689
else:
690
raise
691
br_from.lock_read()
692
try:
693
if basis is not None:
694
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
695
else:
696
basis_dir = None
697
if len(revision) == 1 and revision[0] is not None:
698
revision_id = revision[0].in_history(br_from)[1]
699
else:
700
# FIXME - wt.last_revision, fallback to branch, fall back to
701
# None or perhaps NULL_REVISION to mean copy nothing
702
# RBC 20060209
703
revision_id = br_from.last_revision()
704
if to_location is None:
705
to_location = os.path.basename(from_location.rstrip("/\\"))
706
name = None
707
else:
708
name = os.path.basename(to_location) + '\n'
709
710
to_transport = transport.get_transport(to_location)
711
try:
712
to_transport.mkdir('.')
713
except errors.FileExists:
714
raise BzrCommandError('Target directory "%s" already'
715
' exists.' % to_location)
716
except errors.NoSuchFile:
717
raise BzrCommandError('Parent of "%s" does not exist.' %
718
to_location)
719
try:
720
# preserve whatever source format we have.
721
dir = br_from.bzrdir.sprout(to_transport.base,
722
revision_id, basis_dir)
723
branch = dir.open_branch()
724
except errors.NoSuchRevision:
725
to_transport.delete_tree('.')
726
msg = "The branch %s has no revision %s." % (from_location, revision[0])
727
raise BzrCommandError(msg)
728
except errors.UnlistableBranch:
729
osutils.rmtree(to_location)
730
msg = "The branch %s cannot be used as a --basis" % (basis,)
731
raise BzrCommandError(msg)
732
if name:
733
branch.control_files.put_utf8('branch-name', name)
734
note('Branched %d revision(s).' % branch.revno())
735
finally:
736
br_from.unlock()
737
738
739
class cmd_checkout(Command):
740
"""Create a new checkout of an existing branch.
741
742
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
743
the branch found in '.'. This is useful if you have removed the working tree
744
or if it was never created - i.e. if you pushed the branch to its current
745
location using SFTP.
746
747
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
748
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
749
750
To retrieve the branch as of a particular revision, supply the --revision
751
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
752
out of date [so you cannot commit] but it may be useful (i.e. to examine old
753
code.)
754
755
--basis is to speed up checking out from remote branches. When specified, it
756
uses the inventory and file contents from the basis branch in preference to the
757
branch being checked out.
758
"""
759
takes_args = ['branch_location?', 'to_location?']
760
takes_options = ['revision', # , 'basis']
761
Option('lightweight',
762
help="perform a lightweight checkout. Lightweight "
763
"checkouts depend on access to the branch for "
764
"every operation. Normal checkouts can perform "
765
"common operations like diff and status without "
766
"such access, and also support local commits."
767
),
768
]
769
aliases = ['co']
770
771
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
772
lightweight=False):
773
if revision is None:
774
revision = [None]
775
elif len(revision) > 1:
776
raise BzrCommandError(
777
'bzr checkout --revision takes exactly 1 revision value')
778
if branch_location is None:
779
branch_location = osutils.getcwd()
780
to_location = branch_location
781
source = Branch.open(branch_location)
782
if len(revision) == 1 and revision[0] is not None:
783
revision_id = revision[0].in_history(source)[1]
784
else:
785
revision_id = None
786
if to_location is None:
787
to_location = os.path.basename(branch_location.rstrip("/\\"))
788
# if the source and to_location are the same,
789
# and there is no working tree,
790
# then reconstitute a branch
791
if (osutils.abspath(to_location) ==
792
osutils.abspath(branch_location)):
793
try:
794
source.bzrdir.open_workingtree()
795
except errors.NoWorkingTree:
796
source.bzrdir.create_workingtree()
797
return
798
try:
799
os.mkdir(to_location)
800
except OSError, e:
801
if e.errno == errno.EEXIST:
802
raise BzrCommandError('Target directory "%s" already'
803
' exists.' % to_location)
804
if e.errno == errno.ENOENT:
805
raise BzrCommandError('Parent of "%s" does not exist.' %
806
to_location)
807
else:
808
raise
809
old_format = bzrdir.BzrDirFormat.get_default_format()
810
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
811
try:
812
source.create_checkout(to_location, revision_id, lightweight)
813
finally:
814
bzrdir.BzrDirFormat.set_default_format(old_format)
815
816
817
class cmd_renames(Command):
818
"""Show list of renamed files.
819
"""
820
# TODO: Option to show renames between two historical versions.
821
822
# TODO: Only show renames under dir, rather than in the whole branch.
823
takes_args = ['dir?']
824
825
@display_command
826
def run(self, dir=u'.'):
827
from bzrlib.tree import find_renames
828
tree = WorkingTree.open_containing(dir)[0]
829
old_inv = tree.basis_tree().inventory
830
new_inv = tree.read_working_inventory()
831
renames = list(find_renames(old_inv, new_inv))
832
renames.sort()
833
for old_name, new_name in renames:
834
self.outf.write("%s => %s\n" % (old_name, new_name))
835
836
837
class cmd_update(Command):
838
"""Update a tree to have the latest code committed to its branch.
839
840
This will perform a merge into the working tree, and may generate
841
conflicts. If you have any local changes, you will still
842
need to commit them after the update for the update to be complete.
843
844
If you want to discard your local changes, you can just do a
845
'bzr revert' instead of 'bzr commit' after the update.
846
"""
847
takes_args = ['dir?']
848
aliases = ['up']
849
850
def run(self, dir='.'):
851
tree = WorkingTree.open_containing(dir)[0]
852
tree.lock_write()
853
try:
854
existing_pending_merges = tree.get_parent_ids()[1:]
855
last_rev = tree.last_revision()
856
if last_rev == tree.branch.last_revision():
857
# may be up to date, check master too.
858
master = tree.branch.get_master_branch()
859
if master is None or last_rev == master.last_revision():
860
revno = tree.branch.revision_id_to_revno(last_rev)
861
note("Tree is up to date at revision %d." % (revno,))
862
return 0
863
conflicts = tree.update()
864
revno = tree.branch.revision_id_to_revno(tree.last_revision())
865
note('Updated to revision %d.' % (revno,))
866
if tree.get_parent_ids()[1:] != existing_pending_merges:
867
note('Your local commits will now show as pending merges with '
868
"'bzr status', and can be committed with 'bzr commit'.")
869
if conflicts != 0:
870
return 1
871
else:
872
return 0
873
finally:
874
tree.unlock()
875
876
877
class cmd_info(Command):
878
"""Show information about a working tree, branch or repository.
879
880
This command will show all known locations and formats associated to the
881
tree, branch or repository. Statistical information is included with
882
each report.
883
884
Branches and working trees will also report any missing revisions.
885
"""
886
takes_args = ['location?']
887
takes_options = ['verbose']
888
889
@display_command
890
def run(self, location=None, verbose=False):
891
from bzrlib.info import show_bzrdir_info
892
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
893
verbose=verbose)
894
895
896
class cmd_remove(Command):
897
"""Make a file unversioned.
898
899
This makes bzr stop tracking changes to a versioned file. It does
900
not delete the working copy.
901
902
You can specify one or more files, and/or --new. If you specify --new,
903
only 'added' files will be removed. If you specify both, then new files
904
in the specified directories will be removed. If the directories are
905
also new, they will also be removed.
906
"""
907
takes_args = ['file*']
908
takes_options = ['verbose', Option('new', help='remove newly-added files')]
909
aliases = ['rm']
910
encoding_type = 'replace'
911
912
def run(self, file_list, verbose=False, new=False):
913
tree, file_list = tree_files(file_list)
914
if new is False:
915
if file_list is None:
916
raise BzrCommandError('Specify one or more files to remove, or'
917
' use --new.')
918
else:
919
added = tree.changes_from(tree.basis_tree(),
920
specific_files=file_list).added
921
file_list = sorted([f[0] for f in added], reverse=True)
922
if len(file_list) == 0:
923
raise BzrCommandError('No matching files.')
924
tree.remove(file_list, verbose=verbose, to_file=self.outf)
925
926
927
class cmd_file_id(Command):
928
"""Print file_id of a particular file or directory.
929
930
The file_id is assigned when the file is first added and remains the
931
same through all revisions where the file exists, even when it is
932
moved or renamed.
933
"""
934
935
hidden = True
936
takes_args = ['filename']
937
938
@display_command
939
def run(self, filename):
940
tree, relpath = WorkingTree.open_containing(filename)
941
i = tree.inventory.path2id(relpath)
942
if i is None:
943
raise BzrError("%r is not a versioned file" % filename)
944
else:
945
self.outf.write(i + '\n')
946
947
948
class cmd_file_path(Command):
949
"""Print path of file_ids to a file or directory.
950
951
This prints one line for each directory down to the target,
952
starting at the branch root.
953
"""
954
955
hidden = True
956
takes_args = ['filename']
957
958
@display_command
959
def run(self, filename):
960
tree, relpath = WorkingTree.open_containing(filename)
961
inv = tree.inventory
962
fid = inv.path2id(relpath)
963
if fid is None:
964
raise BzrError("%r is not a versioned file" % filename)
965
for fip in inv.get_idpath(fid):
966
self.outf.write(fip + '\n')
967
968
969
class cmd_reconcile(Command):
970
"""Reconcile bzr metadata in a branch.
971
972
This can correct data mismatches that may have been caused by
973
previous ghost operations or bzr upgrades. You should only
974
need to run this command if 'bzr check' or a bzr developer
975
advises you to run it.
976
977
If a second branch is provided, cross-branch reconciliation is
978
also attempted, which will check that data like the tree root
979
id which was not present in very early bzr versions is represented
980
correctly in both branches.
981
982
At the same time it is run it may recompress data resulting in
983
a potential saving in disk space or performance gain.
984
985
The branch *MUST* be on a listable system such as local disk or sftp.
986
"""
987
takes_args = ['branch?']
988
989
def run(self, branch="."):
990
from bzrlib.reconcile import reconcile
991
dir = bzrdir.BzrDir.open(branch)
992
reconcile(dir)
993
994
995
class cmd_revision_history(Command):
996
"""Display the list of revision ids on a branch."""
997
takes_args = ['location?']
998
999
hidden = True
1000
1001
@display_command
1002
def run(self, location="."):
1003
branch = Branch.open_containing(location)[0]
1004
for revid in branch.revision_history():
1005
self.outf.write(revid)
1006
self.outf.write('\n')
1007
1008
1009
class cmd_ancestry(Command):
1010
"""List all revisions merged into this branch."""
1011
takes_args = ['location?']
1012
1013
hidden = True
1014
1015
@display_command
1016
def run(self, location="."):
1017
try:
1018
wt = WorkingTree.open_containing(location)[0]
1019
except errors.NoWorkingTree:
1020
b = Branch.open(location)
1021
last_revision = b.last_revision()
1022
else:
1023
b = wt.branch
1024
last_revision = wt.last_revision()
1025
1026
revision_ids = b.repository.get_ancestry(last_revision)
1027
assert revision_ids[0] is None
1028
revision_ids.pop(0)
1029
for revision_id in revision_ids:
1030
self.outf.write(revision_id + '\n')
1031
1032
1033
class cmd_init(Command):
1034
"""Make a directory into a versioned branch.
1035
1036
Use this to create an empty branch, or before importing an
1037
existing project.
1038
1039
If there is a repository in a parent directory of the location, then
1040
the history of the branch will be stored in the repository. Otherwise
1041
init creates a standalone branch which carries its own history in
1042
.bzr.
1043
1044
If there is already a branch at the location but it has no working tree,
1045
the tree can be populated with 'bzr checkout'.
1046
1047
Recipe for importing a tree of files:
1048
cd ~/project
1049
bzr init
1050
bzr add .
1051
bzr status
1052
bzr commit -m 'imported project'
1053
"""
1054
takes_args = ['location?']
1055
takes_options = [
1056
Option('format',
1057
help='Specify a format for this branch. Current'
1058
' formats are: default, knit, metaweave and'
1059
' weave. Default is knit; metaweave and'
1060
' weave are deprecated',
1061
type=get_format_type),
1062
]
1063
def run(self, location=None, format=None):
1064
if format is None:
1065
format = get_format_type('default')
1066
if location is None:
1067
location = u'.'
1068
1069
to_transport = transport.get_transport(location)
1070
1071
# The path has to exist to initialize a
1072
# branch inside of it.
1073
# Just using os.mkdir, since I don't
1074
# believe that we want to create a bunch of
1075
# locations if the user supplies an extended path
1076
# TODO: create-prefix
1077
try:
1078
to_transport.mkdir('.')
1079
except errors.FileExists:
1080
pass
1081
1082
try:
1083
existing_bzrdir = bzrdir.BzrDir.open(location)
1084
except NotBranchError:
1085
# really a NotBzrDir error...
1086
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1087
else:
1088
if existing_bzrdir.has_branch():
1089
if (isinstance(to_transport, LocalTransport)
1090
and not existing_bzrdir.has_workingtree()):
1091
raise errors.BranchExistsWithoutWorkingTree(location)
1092
raise errors.AlreadyBranchError(location)
1093
else:
1094
existing_bzrdir.create_branch()
1095
existing_bzrdir.create_workingtree()
1096
1097
1098
class cmd_init_repository(Command):
1099
"""Create a shared repository to hold branches.
1100
1101
New branches created under the repository directory will store their revisions
1102
in the repository, not in the branch directory, if the branch format supports
1103
shared storage.
1104
1105
example:
1106
bzr init-repo repo
1107
bzr init repo/trunk
1108
bzr checkout --lightweight repo/trunk trunk-checkout
1109
cd trunk-checkout
1110
(add files here)
1111
"""
1112
takes_args = ["location"]
1113
takes_options = [Option('format',
1114
help='Specify a format for this repository.'
1115
' Current formats are: default, knit,'
1116
' metaweave and weave. Default is knit;'
1117
' metaweave and weave are deprecated',
1118
type=get_format_type),
1119
Option('trees',
1120
help='Allows branches in repository to have'
1121
' a working tree')]
1122
aliases = ["init-repo"]
1123
def run(self, location, format=None, trees=False):
1124
if format is None:
1125
format = get_format_type('default')
1126
1127
if location is None:
1128
location = '.'
1129
1130
to_transport = transport.get_transport(location)
1131
try:
1132
to_transport.mkdir('.')
1133
except errors.FileExists:
1134
pass
1135
1136
newdir = format.initialize_on_transport(to_transport)
1137
repo = newdir.create_repository(shared=True)
1138
repo.set_make_working_trees(trees)
1139
1140
1141
class cmd_diff(Command):
1142
"""Show differences in the working tree or between revisions.
1143
1144
If files are listed, only the changes in those files are listed.
1145
Otherwise, all changes for the tree are listed.
1146
1147
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1148
produces patches suitable for "patch -p1".
1149
1150
examples:
1151
bzr diff
1152
Shows the difference in the working tree versus the last commit
1153
bzr diff -r1
1154
Difference between the working tree and revision 1
1155
bzr diff -r1..2
1156
Difference between revision 2 and revision 1
1157
bzr diff --diff-prefix old/:new/
1158
Same as 'bzr diff' but prefix paths with old/ and new/
1159
bzr diff bzr.mine bzr.dev
1160
Show the differences between the two working trees
1161
bzr diff foo.c
1162
Show just the differences for 'foo.c'
1163
"""
1164
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1165
# or a graphical diff.
1166
1167
# TODO: Python difflib is not exactly the same as unidiff; should
1168
# either fix it up or prefer to use an external diff.
1169
1170
# TODO: Selected-file diff is inefficient and doesn't show you
1171
# deleted files.
1172
1173
# TODO: This probably handles non-Unix newlines poorly.
1174
1175
takes_args = ['file*']
1176
takes_options = ['revision', 'diff-options', 'prefix']
1177
aliases = ['di', 'dif']
1178
encoding_type = 'exact'
1179
1180
@display_command
1181
def run(self, revision=None, file_list=None, diff_options=None,
1182
prefix=None):
1183
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1184
1185
if (prefix is None) or (prefix == '0'):
1186
# diff -p0 format
1187
old_label = ''
1188
new_label = ''
1189
elif prefix == '1':
1190
old_label = 'old/'
1191
new_label = 'new/'
1192
else:
1193
if not ':' in prefix:
1194
raise BzrError("--diff-prefix expects two values separated by a colon")
1195
old_label, new_label = prefix.split(":")
1196
1197
try:
1198
tree1, file_list = internal_tree_files(file_list)
1199
tree2 = None
1200
b = None
1201
b2 = None
1202
except FileInWrongBranch:
1203
if len(file_list) != 2:
1204
raise BzrCommandError("Files are in different branches")
1205
1206
tree1, file1 = WorkingTree.open_containing(file_list[0])
1207
tree2, file2 = WorkingTree.open_containing(file_list[1])
1208
if file1 != "" or file2 != "":
1209
# FIXME diff those two files. rbc 20051123
1210
raise BzrCommandError("Files are in different branches")
1211
file_list = None
1212
except NotBranchError:
1213
if (revision is not None and len(revision) == 2
1214
and not revision[0].needs_branch()
1215
and not revision[1].needs_branch()):
1216
# If both revision specs include a branch, we can
1217
# diff them without needing a local working tree
1218
tree1, tree2 = None, None
1219
else:
1220
raise
1221
if revision is not None:
1222
if tree2 is not None:
1223
raise BzrCommandError("Can't specify -r with two branches")
1224
if (len(revision) == 1) or (revision[1].spec is None):
1225
return diff_cmd_helper(tree1, file_list, diff_options,
1226
revision[0],
1227
old_label=old_label, new_label=new_label)
1228
elif len(revision) == 2:
1229
return diff_cmd_helper(tree1, file_list, diff_options,
1230
revision[0], revision[1],
1231
old_label=old_label, new_label=new_label)
1232
else:
1233
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1234
else:
1235
if tree2 is not None:
1236
return show_diff_trees(tree1, tree2, sys.stdout,
1237
specific_files=file_list,
1238
external_diff_options=diff_options,
1239
old_label=old_label, new_label=new_label)
1240
else:
1241
return diff_cmd_helper(tree1, file_list, diff_options,
1242
old_label=old_label, new_label=new_label)
1243
1244
1245
class cmd_deleted(Command):
1246
"""List files deleted in the working tree.
1247
"""
1248
# TODO: Show files deleted since a previous revision, or
1249
# between two revisions.
1250
# TODO: Much more efficient way to do this: read in new
1251
# directories with readdir, rather than stating each one. Same
1252
# level of effort but possibly much less IO. (Or possibly not,
1253
# if the directories are very large...)
1254
takes_options = ['show-ids']
1255
1256
@display_command
1257
def run(self, show_ids=False):
1258
tree = WorkingTree.open_containing(u'.')[0]
1259
old = tree.basis_tree()
1260
for path, ie in old.inventory.iter_entries():
1261
if not tree.has_id(ie.file_id):
1262
self.outf.write(path)
1263
if show_ids:
1264
self.outf.write(' ')
1265
self.outf.write(ie.file_id)
1266
self.outf.write('\n')
1267
1268
1269
class cmd_modified(Command):
1270
"""List files modified in working tree."""
1271
hidden = True
1272
@display_command
1273
def run(self):
1274
tree = WorkingTree.open_containing(u'.')[0]
1275
td = tree.changes_from(tree.basis_tree())
1276
for path, id, kind, text_modified, meta_modified in td.modified:
1277
self.outf.write(path + '\n')
1278
1279
1280
class cmd_added(Command):
1281
"""List files added in working tree."""
1282
hidden = True
1283
@display_command
1284
def run(self):
1285
wt = WorkingTree.open_containing(u'.')[0]
1286
basis_inv = wt.basis_tree().inventory
1287
inv = wt.inventory
1288
for file_id in inv:
1289
if file_id in basis_inv:
1290
continue
1291
if inv.is_root(file_id) and len(basis_inv) == 0:
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(include_root=False):
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 BzrError, 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 common_ancestor, 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 merge import merge_type_help
2156
from inspect import getdoc
2157
return getdoc(self) + '\n' + merge_type_help()
2158
2159
def run(self, branch=None, revision=None, force=False, merge_type=None,
2160
show_base=False, reprocess=False, remember=False,
2161
uncommitted=False):
2162
if merge_type is None:
2163
merge_type = Merge3Merger
2164
2165
tree = WorkingTree.open_containing(u'.')[0]
2166
2167
if branch is not None:
2168
try:
2169
reader = bundle.read_bundle_from_url(branch)
2170
except NotABundle:
2171
pass # Continue on considering this url a Branch
2172
else:
2173
conflicts = merge_bundle(reader, tree, not force, merge_type,
2174
reprocess, show_base)
2175
if conflicts == 0:
2176
return 0
2177
else:
2178
return 1
2179
2180
if revision is None \
2181
or len(revision) < 1 or revision[0].needs_branch():
2182
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2183
2184
if revision is None or len(revision) < 1:
2185
if uncommitted:
2186
base = [branch, -1]
2187
other = [branch, None]
2188
else:
2189
base = [None, None]
2190
other = [branch, -1]
2191
other_branch, path = Branch.open_containing(branch)
2192
else:
2193
if uncommitted:
2194
raise BzrCommandError('Cannot use --uncommitted and --revision'
2195
' at the same time.')
2196
branch = revision[0].get_branch() or branch
2197
if len(revision) == 1:
2198
base = [None, None]
2199
other_branch, path = Branch.open_containing(branch)
2200
revno = revision[0].in_history(other_branch).revno
2201
other = [branch, revno]
2202
else:
2203
assert len(revision) == 2
2204
if None in revision:
2205
raise BzrCommandError(
2206
"Merge doesn't permit empty revision specifier.")
2207
base_branch, path = Branch.open_containing(branch)
2208
branch1 = revision[1].get_branch() or branch
2209
other_branch, path1 = Branch.open_containing(branch1)
2210
if revision[0].get_branch() is not None:
2211
# then path was obtained from it, and is None.
2212
path = path1
2213
2214
base = [branch, revision[0].in_history(base_branch).revno]
2215
other = [branch1, revision[1].in_history(other_branch).revno]
2216
2217
if tree.branch.get_parent() is None or remember:
2218
tree.branch.set_parent(other_branch.base)
2219
2220
if path != "":
2221
interesting_files = [path]
2222
else:
2223
interesting_files = None
2224
pb = ui.ui_factory.nested_progress_bar()
2225
try:
2226
try:
2227
conflict_count = merge(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 merge import merge_type_help
2292
from inspect import getdoc
2293
return getdoc(self) + '\n' + merge_type_help()
2294
2295
def run(self, file_list=None, merge_type=None, show_base=False,
2296
reprocess=False):
2297
from bzrlib.merge import merge_inner, transform_tree
2298
if merge_type is None:
2299
merge_type = Merge3Merger
2300
tree, file_list = tree_files(file_list)
2301
tree.lock_write()
2302
try:
2303
parents = tree.get_parent_ids()
2304
if len(parents) != 2:
2305
raise BzrCommandError("Sorry, remerge only works after normal"
2306
" merges. Not cherrypicking or"
2307
" multi-merges.")
2308
repository = tree.branch.repository
2309
base_revision = common_ancestor(parents[0],
2310
parents[1], repository)
2311
base_tree = repository.revision_tree(base_revision)
2312
other_tree = repository.revision_tree(parents[1])
2313
interesting_ids = None
2314
new_conflicts = []
2315
conflicts = tree.conflicts()
2316
if file_list is not None:
2317
interesting_ids = set()
2318
for filename in file_list:
2319
file_id = tree.path2id(filename)
2320
if file_id is None:
2321
raise NotVersionedError(filename)
2322
interesting_ids.add(file_id)
2323
if tree.kind(file_id) != "directory":
2324
continue
2325
2326
for name, ie in tree.inventory.iter_entries(file_id):
2327
interesting_ids.add(ie.file_id)
2328
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2329
transform_tree(tree, tree.basis_tree(), interesting_ids)
2330
tree.set_conflicts(ConflictList(new_conflicts))
2331
if file_list is None:
2332
restore_files = list(tree.iter_conflicts())
2333
else:
2334
restore_files = file_list
2335
for filename in restore_files:
2336
try:
2337
restore(tree.abspath(filename))
2338
except NotConflicted:
2339
pass
2340
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2341
this_tree=tree,
2342
interesting_ids=interesting_ids,
2343
other_rev_id=parents[1],
2344
merge_type=merge_type,
2345
show_base=show_base,
2346
reprocess=reprocess)
2347
finally:
2348
tree.unlock()
2349
if conflicts > 0:
2350
return 1
2351
else:
2352
return 0
2353
2354
class cmd_revert(Command):
2355
"""Revert files to a previous revision.
2356
2357
Giving a list of files will revert only those files. Otherwise, all files
2358
will be reverted. If the revision is not specified with '--revision', the
2359
last committed revision is used.
2360
2361
To remove only some changes, without reverting to a prior version, use
2362
merge instead. For example, "merge . --r-2..-3" will remove the changes
2363
introduced by -2, without affecting the changes introduced by -1. Or
2364
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2365
2366
By default, any files that have been manually changed will be backed up
2367
first. (Files changed only by merge are not backed up.) Backup files have
2368
'.~#~' appended to their name, where # is a number.
2369
2370
When you provide files, you can use their current pathname or the pathname
2371
from the target revision. So you can use revert to "undelete" a file by
2372
name. If you name a directory, all the contents of that directory will be
2373
reverted.
2374
"""
2375
takes_options = ['revision', 'no-backup']
2376
takes_args = ['file*']
2377
aliases = ['merge-revert']
2378
2379
def run(self, revision=None, no_backup=False, file_list=None):
2380
from bzrlib.commands import parse_spec
2381
if file_list is not None:
2382
if len(file_list) == 0:
2383
raise BzrCommandError("No files specified")
2384
else:
2385
file_list = []
2386
2387
tree, file_list = tree_files(file_list)
2388
if revision is None:
2389
# FIXME should be tree.last_revision
2390
rev_id = tree.last_revision()
2391
elif len(revision) != 1:
2392
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2393
else:
2394
rev_id = revision[0].in_history(tree.branch).rev_id
2395
pb = ui.ui_factory.nested_progress_bar()
2396
try:
2397
tree.revert(file_list,
2398
tree.branch.repository.revision_tree(rev_id),
2399
not no_backup, pb)
2400
finally:
2401
pb.finished()
2402
2403
2404
class cmd_assert_fail(Command):
2405
"""Test reporting of assertion failures"""
2406
hidden = True
2407
def run(self):
2408
assert False, "always fails"
2409
2410
2411
class cmd_help(Command):
2412
"""Show help on a command or other topic.
2413
2414
For a list of all available commands, say 'bzr help commands'."""
2415
takes_options = [Option('long', 'show help on all commands')]
2416
takes_args = ['topic?']
2417
aliases = ['?', '--help', '-?', '-h']
2418
2419
@display_command
2420
def run(self, topic=None, long=False):
2421
import help
2422
if topic is None and long:
2423
topic = "commands"
2424
help.help(topic)
2425
2426
2427
class cmd_shell_complete(Command):
2428
"""Show appropriate completions for context.
2429
2430
For a list of all available commands, say 'bzr shell-complete'."""
2431
takes_args = ['context?']
2432
aliases = ['s-c']
2433
hidden = True
2434
2435
@display_command
2436
def run(self, context=None):
2437
import shellcomplete
2438
shellcomplete.shellcomplete(context)
2439
2440
2441
class cmd_fetch(Command):
2442
"""Copy in history from another branch but don't merge it.
2443
2444
This is an internal method used for pull and merge."""
2445
hidden = True
2446
takes_args = ['from_branch', 'to_branch']
2447
def run(self, from_branch, to_branch):
2448
from bzrlib.fetch import Fetcher
2449
from_b = Branch.open(from_branch)
2450
to_b = Branch.open(to_branch)
2451
Fetcher(to_b, from_b)
2452
2453
2454
class cmd_missing(Command):
2455
"""Show unmerged/unpulled revisions between two branches.
2456
2457
OTHER_BRANCH may be local or remote."""
2458
takes_args = ['other_branch?']
2459
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2460
Option('mine-only',
2461
'Display changes in the local branch only'),
2462
Option('theirs-only',
2463
'Display changes in the remote branch only'),
2464
'log-format',
2465
'line',
2466
'long',
2467
'short',
2468
'show-ids',
2469
'verbose'
2470
]
2471
encoding_type = 'replace'
2472
2473
@display_command
2474
def run(self, other_branch=None, reverse=False, mine_only=False,
2475
theirs_only=False, log_format=None, long=False, short=False, line=False,
2476
show_ids=False, verbose=False):
2477
from bzrlib.missing import find_unmerged, iter_log_data
2478
from bzrlib.log import log_formatter
2479
local_branch = Branch.open_containing(u".")[0]
2480
parent = local_branch.get_parent()
2481
if other_branch is None:
2482
other_branch = parent
2483
if other_branch is None:
2484
raise BzrCommandError("No peer location known or specified.")
2485
print "Using last location: " + local_branch.get_parent()
2486
remote_branch = Branch.open(other_branch)
2487
if remote_branch.base == local_branch.base:
2488
remote_branch = local_branch
2489
local_branch.lock_read()
2490
try:
2491
remote_branch.lock_read()
2492
try:
2493
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2494
if (log_format is None):
2495
default = local_branch.get_config().log_format()
2496
log_format = get_log_format(long=long, short=short,
2497
line=line, default=default)
2498
lf = log_formatter(log_format,
2499
to_file=self.outf,
2500
show_ids=show_ids,
2501
show_timezone='original')
2502
if reverse is False:
2503
local_extra.reverse()
2504
remote_extra.reverse()
2505
if local_extra and not theirs_only:
2506
print "You have %d extra revision(s):" % len(local_extra)
2507
for data in iter_log_data(local_extra, local_branch.repository,
2508
verbose):
2509
lf.show(*data)
2510
printed_local = True
2511
else:
2512
printed_local = False
2513
if remote_extra and not mine_only:
2514
if printed_local is True:
2515
print "\n\n"
2516
print "You are missing %d revision(s):" % len(remote_extra)
2517
for data in iter_log_data(remote_extra, remote_branch.repository,
2518
verbose):
2519
lf.show(*data)
2520
if not remote_extra and not local_extra:
2521
status_code = 0
2522
print "Branches are up to date."
2523
else:
2524
status_code = 1
2525
finally:
2526
remote_branch.unlock()
2527
finally:
2528
local_branch.unlock()
2529
if not status_code and parent is None and other_branch is not None:
2530
local_branch.lock_write()
2531
try:
2532
# handle race conditions - a parent might be set while we run.
2533
if local_branch.get_parent() is None:
2534
local_branch.set_parent(remote_branch.base)
2535
finally:
2536
local_branch.unlock()
2537
return status_code
2538
2539
2540
class cmd_plugins(Command):
2541
"""List plugins"""
2542
hidden = True
2543
@display_command
2544
def run(self):
2545
import bzrlib.plugin
2546
from inspect import getdoc
2547
for name, plugin in bzrlib.plugin.all_plugins().items():
2548
if getattr(plugin, '__path__', None) is not None:
2549
print plugin.__path__[0]
2550
elif getattr(plugin, '__file__', None) is not None:
2551
print plugin.__file__
2552
else:
2553
print repr(plugin)
2554
2555
d = getdoc(plugin)
2556
if d:
2557
print '\t', d.split('\n')[0]
2558
2559
2560
class cmd_testament(Command):
2561
"""Show testament (signing-form) of a revision."""
2562
takes_options = ['revision',
2563
Option('long', help='Produce long-format testament'),
2564
Option('strict', help='Produce a strict-format'
2565
' testament')]
2566
takes_args = ['branch?']
2567
@display_command
2568
def run(self, branch=u'.', revision=None, long=False, strict=False):
2569
from bzrlib.testament import Testament, StrictTestament
2570
if strict is True:
2571
testament_class = StrictTestament
2572
else:
2573
testament_class = Testament
2574
b = WorkingTree.open_containing(branch)[0].branch
2575
b.lock_read()
2576
try:
2577
if revision is None:
2578
rev_id = b.last_revision()
2579
else:
2580
rev_id = revision[0].in_history(b).rev_id
2581
t = testament_class.from_revision(b.repository, rev_id)
2582
if long:
2583
sys.stdout.writelines(t.as_text_lines())
2584
else:
2585
sys.stdout.write(t.as_short_text())
2586
finally:
2587
b.unlock()
2588
2589
2590
class cmd_annotate(Command):
2591
"""Show the origin of each line in a file.
2592
2593
This prints out the given file with an annotation on the left side
2594
indicating which revision, author and date introduced the change.
2595
2596
If the origin is the same for a run of consecutive lines, it is
2597
shown only at the top, unless the --all option is given.
2598
"""
2599
# TODO: annotate directories; showing when each file was last changed
2600
# TODO: if the working copy is modified, show annotations on that
2601
# with new uncommitted lines marked
2602
aliases = ['ann', 'blame', 'praise']
2603
takes_args = ['filename']
2604
takes_options = [Option('all', help='show annotations on all lines'),
2605
Option('long', help='show date in annotations'),
2606
'revision'
2607
]
2608
2609
@display_command
2610
def run(self, filename, all=False, long=False, revision=None):
2611
from bzrlib.annotate import annotate_file
2612
tree, relpath = WorkingTree.open_containing(filename)
2613
branch = tree.branch
2614
branch.lock_read()
2615
try:
2616
if revision is None:
2617
revision_id = branch.last_revision()
2618
elif len(revision) != 1:
2619
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2620
else:
2621
revision_id = revision[0].in_history(branch).rev_id
2622
file_id = tree.inventory.path2id(relpath)
2623
tree = branch.repository.revision_tree(revision_id)
2624
file_version = tree.inventory[file_id].revision
2625
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2626
finally:
2627
branch.unlock()
2628
2629
2630
class cmd_re_sign(Command):
2631
"""Create a digital signature for an existing revision."""
2632
# TODO be able to replace existing ones.
2633
2634
hidden = True # is this right ?
2635
takes_args = ['revision_id*']
2636
takes_options = ['revision']
2637
2638
def run(self, revision_id_list=None, revision=None):
2639
import bzrlib.gpg as gpg
2640
if revision_id_list is not None and revision is not None:
2641
raise BzrCommandError('You can only supply one of revision_id or --revision')
2642
if revision_id_list is None and revision is None:
2643
raise BzrCommandError('You must supply either --revision or a revision_id')
2644
b = WorkingTree.open_containing(u'.')[0].branch
2645
gpg_strategy = gpg.GPGStrategy(b.get_config())
2646
if revision_id_list is not None:
2647
for revision_id in revision_id_list:
2648
b.repository.sign_revision(revision_id, gpg_strategy)
2649
elif revision is not None:
2650
if len(revision) == 1:
2651
revno, rev_id = revision[0].in_history(b)
2652
b.repository.sign_revision(rev_id, gpg_strategy)
2653
elif len(revision) == 2:
2654
# are they both on rh- if so we can walk between them
2655
# might be nice to have a range helper for arbitrary
2656
# revision paths. hmm.
2657
from_revno, from_revid = revision[0].in_history(b)
2658
to_revno, to_revid = revision[1].in_history(b)
2659
if to_revid is None:
2660
to_revno = b.revno()
2661
if from_revno is None or to_revno is None:
2662
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2663
for revno in range(from_revno, to_revno + 1):
2664
b.repository.sign_revision(b.get_rev_id(revno),
2665
gpg_strategy)
2666
else:
2667
raise BzrCommandError('Please supply either one revision, or a range.')
2668
2669
2670
class cmd_bind(Command):
2671
"""Bind the current branch to a master branch.
2672
2673
After binding, commits must succeed on the master branch
2674
before they are executed on the local one.
2675
"""
2676
2677
takes_args = ['location']
2678
takes_options = []
2679
2680
def run(self, location=None):
2681
b, relpath = Branch.open_containing(u'.')
2682
b_other = Branch.open(location)
2683
try:
2684
b.bind(b_other)
2685
except DivergedBranches:
2686
raise BzrCommandError('These branches have diverged.'
2687
' Try merging, and then bind again.')
2688
2689
2690
class cmd_unbind(Command):
2691
"""Unbind the current branch from its master branch.
2692
2693
After unbinding, the local branch is considered independent.
2694
All subsequent commits will be local.
2695
"""
2696
2697
takes_args = []
2698
takes_options = []
2699
2700
def run(self):
2701
b, relpath = Branch.open_containing(u'.')
2702
if not b.unbind():
2703
raise BzrCommandError('Local branch is not bound')
2704
2705
2706
class cmd_uncommit(Command):
2707
"""Remove the last committed revision.
2708
2709
--verbose will print out what is being removed.
2710
--dry-run will go through all the motions, but not actually
2711
remove anything.
2712
2713
In the future, uncommit will create a revision bundle, which can then
2714
be re-applied.
2715
"""
2716
2717
# TODO: jam 20060108 Add an option to allow uncommit to remove
2718
# unreferenced information in 'branch-as-repository' branches.
2719
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2720
# information in shared branches as well.
2721
takes_options = ['verbose', 'revision',
2722
Option('dry-run', help='Don\'t actually make changes'),
2723
Option('force', help='Say yes to all questions.')]
2724
takes_args = ['location?']
2725
aliases = []
2726
2727
def run(self, location=None,
2728
dry_run=False, verbose=False,
2729
revision=None, force=False):
2730
from bzrlib.log import log_formatter, show_log
2731
import sys
2732
from bzrlib.uncommit import uncommit
2733
2734
if location is None:
2735
location = u'.'
2736
control, relpath = bzrdir.BzrDir.open_containing(location)
2737
try:
2738
tree = control.open_workingtree()
2739
b = tree.branch
2740
except (errors.NoWorkingTree, errors.NotLocalUrl):
2741
tree = None
2742
b = control.open_branch()
2743
2744
rev_id = None
2745
if revision is None:
2746
revno = b.revno()
2747
else:
2748
# 'bzr uncommit -r 10' actually means uncommit
2749
# so that the final tree is at revno 10.
2750
# but bzrlib.uncommit.uncommit() actually uncommits
2751
# the revisions that are supplied.
2752
# So we need to offset it by one
2753
revno = revision[0].in_history(b).revno+1
2754
2755
if revno <= b.revno():
2756
rev_id = b.get_rev_id(revno)
2757
if rev_id is None:
2758
self.outf.write('No revisions to uncommit.\n')
2759
return 1
2760
2761
lf = log_formatter('short',
2762
to_file=self.outf,
2763
show_timezone='original')
2764
2765
show_log(b,
2766
lf,
2767
verbose=False,
2768
direction='forward',
2769
start_revision=revno,
2770
end_revision=b.revno())
2771
2772
if dry_run:
2773
print 'Dry-run, pretending to remove the above revisions.'
2774
if not force:
2775
val = raw_input('Press <enter> to continue')
2776
else:
2777
print 'The above revision(s) will be removed.'
2778
if not force:
2779
val = raw_input('Are you sure [y/N]? ')
2780
if val.lower() not in ('y', 'yes'):
2781
print 'Canceled'
2782
return 0
2783
2784
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2785
revno=revno)
2786
2787
2788
class cmd_break_lock(Command):
2789
"""Break a dead lock on a repository, branch or working directory.
2790
2791
CAUTION: Locks should only be broken when you are sure that the process
2792
holding the lock has been stopped.
2793
2794
You can get information on what locks are open via the 'bzr info' command.
2795
2796
example:
2797
bzr break-lock
2798
"""
2799
takes_args = ['location?']
2800
2801
def run(self, location=None, show=False):
2802
if location is None:
2803
location = u'.'
2804
control, relpath = bzrdir.BzrDir.open_containing(location)
2805
try:
2806
control.break_lock()
2807
except NotImplementedError:
2808
pass
2809
2810
2811
class cmd_wait_until_signalled(Command):
2812
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
2813
2814
This just prints a line to signal when it is ready, then blocks on stdin.
2815
"""
2816
2817
hidden = True
2818
2819
def run(self):
2820
sys.stdout.write("running\n")
2821
sys.stdout.flush()
2822
sys.stdin.readline()
2823
2824
2825
class cmd_serve(Command):
2826
"""Run the bzr server."""
2827
2828
aliases = ['server']
2829
2830
takes_options = [
2831
Option('inet',
2832
help='serve on stdin/out for use from inetd or sshd'),
2833
Option('port',
2834
help='listen for connections on nominated port of the form '
2835
'[hostname:]portnumber. Passing 0 as the port number will '
2836
'result in a dynamically allocated port.',
2837
type=str),
2838
Option('directory',
2839
help='serve contents of directory',
2840
type=unicode),
2841
Option('allow-writes',
2842
help='By default the server is a readonly server. Supplying '
2843
'--allow-writes enables write access to the contents of '
2844
'the served directory and below. '
2845
),
2846
]
2847
2848
def run(self, port=None, inet=False, directory=None, allow_writes=False):
2849
from bzrlib.transport import smart
2850
from bzrlib.transport import get_transport
2851
if directory is None:
2852
directory = os.getcwd()
2853
url = urlutils.local_path_to_url(directory)
2854
if not allow_writes:
2855
url = 'readonly+' + url
2856
t = get_transport(url)
2857
if inet:
2858
server = smart.SmartStreamServer(sys.stdin, sys.stdout, t)
2859
elif port is not None:
2860
if ':' in port:
2861
host, port = port.split(':')
2862
else:
2863
host = '127.0.0.1'
2864
server = smart.SmartTCPServer(t, host=host, port=int(port))
2865
print 'listening on port: ', server.port
2866
sys.stdout.flush()
2867
else:
2868
raise BzrCommandError("bzr serve requires one of --inet or --port")
2869
server.serve()
2870
2871
2872
# command-line interpretation helper for merge-related commands
2873
def merge(other_revision, base_revision,
2874
check_clean=True, ignore_zero=False,
2875
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2876
file_list=None, show_base=False, reprocess=False,
2877
pb=DummyProgress()):
2878
"""Merge changes into a tree.
2879
2880
base_revision
2881
list(path, revno) Base for three-way merge.
2882
If [None, None] then a base will be automatically determined.
2883
other_revision
2884
list(path, revno) Other revision for three-way merge.
2885
this_dir
2886
Directory to merge changes into; '.' by default.
2887
check_clean
2888
If true, this_dir must have no uncommitted changes before the
2889
merge begins.
2890
ignore_zero - If true, suppress the "zero conflicts" message when
2891
there are no conflicts; should be set when doing something we expect
2892
to complete perfectly.
2893
file_list - If supplied, merge only changes to selected files.
2894
2895
All available ancestors of other_revision and base_revision are
2896
automatically pulled into the branch.
2897
2898
The revno may be -1 to indicate the last revision on the branch, which is
2899
the typical case.
2900
2901
This function is intended for use from the command line; programmatic
2902
clients might prefer to call merge.merge_inner(), which has less magic
2903
behavior.
2904
"""
2905
from bzrlib.merge import Merger
2906
if this_dir is None:
2907
this_dir = u'.'
2908
this_tree = WorkingTree.open_containing(this_dir)[0]
2909
if show_base and not merge_type is Merge3Merger:
2910
raise BzrCommandError("Show-base is not supported for this merge"
2911
" type. %s" % merge_type)
2912
if reprocess and not merge_type.supports_reprocess:
2913
raise BzrCommandError("Conflict reduction is not supported for merge"
2914
" type %s." % merge_type)
2915
if reprocess and show_base:
2916
raise BzrCommandError("Cannot do conflict reduction and show base.")
2917
try:
2918
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2919
merger.pp = ProgressPhase("Merge phase", 5, pb)
2920
merger.pp.next_phase()
2921
merger.check_basis(check_clean)
2922
merger.set_other(other_revision)
2923
merger.pp.next_phase()
2924
merger.set_base(base_revision)
2925
if merger.base_rev_id == merger.other_rev_id:
2926
note('Nothing to do.')
2927
return 0
2928
merger.backup_files = backup_files
2929
merger.merge_type = merge_type
2930
merger.set_interesting_files(file_list)
2931
merger.show_base = show_base
2932
merger.reprocess = reprocess
2933
conflicts = merger.do_merge()
2934
if file_list is None:
2935
merger.set_pending()
2936
finally:
2937
pb.clear()
2938
return conflicts
2939
2940
2941
# these get imported and then picked up by the scan for cmd_*
2942
# TODO: Some more consistent way to split command definitions across files;
2943
# we do need to load at least some information about them to know of
2944
# aliases. ideally we would avoid loading the implementation until the
2945
# details were needed.
2946
from bzrlib.cmd_version_info import cmd_version_info
2947
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2948
from bzrlib.bundle.commands import cmd_bundle_revisions
2949
from bzrlib.sign_my_commits import cmd_sign_my_commits
2950
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2951
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0