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