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