« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 0.1.85
- compare with another revision
- download diff
- download tarball
- view history from revision 0.1.85
- Committer: Martin Pool
- Date: 2005-06-30 10:00:57 UTC
- mto: This revision was merged to the branch mainline in revision 852.
- Revision ID: mbp@sourcefrog.net-20050630100057-32a93074b0f1faa8
doc
- files added:
- .bzrignore
- files removed:
- .bzrignore
- bzrlib
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- doc
- notes
- patches
- tools
- files renamed:
- tools/convertfile.py => convertfile.py
- tools/convertinv.py => convertinv.py
- bzrlib/selftest/test_weave.py => testweave.py
- bzrlib/weave.py => weave.py
- bzrlib/weavefile.py => weavefile.py
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005 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
18
import sys
19
import os
20
21
import bzrlib
22
import bzrlib.trace
23
from bzrlib.trace import mutter, note, log_error, warning
24
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
25
from bzrlib.errors import DivergedBranches
26
from bzrlib.branch import Branch
27
from bzrlib import BZRDIR
28
from bzrlib.commands import Command
29
30
31
class cmd_status(Command):
32
"""Display status summary.
33
34
This reports on versioned and unknown files, reporting them
35
grouped by state. Possible states are:
36
37
added
38
Versioned in the working copy but not in the previous revision.
39
40
removed
41
Versioned in the previous revision but removed or deleted
42
in the working copy.
43
44
renamed
45
Path of this file changed from the previous revision;
46
the text may also have changed. This includes files whose
47
parent directory was renamed.
48
49
modified
50
Text has changed since the previous revision.
51
52
unchanged
53
Nothing about this file has changed since the previous revision.
54
Only shown with --all.
55
56
unknown
57
Not versioned and not matching an ignore pattern.
58
59
To see ignored files use 'bzr ignored'. For details in the
60
changes to file texts, use 'bzr diff'.
61
62
If no arguments are specified, the status of the entire working
63
directory is shown. Otherwise, only the status of the specified
64
files or directories is reported. If a directory is given, status
65
is reported for everything inside that directory.
66
67
If a revision argument is given, the status is calculated against
68
that revision, or between two revisions if two are provided.
69
"""
70
# XXX: FIXME: bzr status should accept a -r option to show changes
71
# relative to a revision, or between revisions
72
73
takes_args = ['file*']
74
takes_options = ['all', 'show-ids']
75
aliases = ['st', 'stat']
76
77
def run(self, all=False, show_ids=False, file_list=None, revision=None):
78
if file_list:
79
b = Branch.open_containing(file_list[0])
80
file_list = [b.relpath(x) for x in file_list]
81
# special case: only one path was given and it's the root
82
# of the branch
83
if file_list == ['']:
84
file_list = None
85
else:
86
b = Branch.open_containing('.')
87
88
from bzrlib.status import show_status
89
show_status(b, show_unchanged=all, show_ids=show_ids,
90
specific_files=file_list, revision=revision)
91
92
93
class cmd_cat_revision(Command):
94
"""Write out metadata for a revision.
95
96
The revision to print can either be specified by a specific
97
revision identifier, or you can use --revision.
98
"""
99
100
hidden = True
101
takes_args = ['revision_id?']
102
takes_options = ['revision']
103
104
def run(self, revision_id=None, revision=None):
105
from bzrlib.revisionspec import RevisionSpec
106
107
if revision_id is not None and revision is not None:
108
raise BzrCommandError('You can only supply one of revision_id or --revision')
109
if revision_id is None and revision is None:
110
raise BzrCommandError('You must supply either --revision or a revision_id')
111
b = Branch.open_containing('.')
112
if revision_id is not None:
113
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
114
elif revision is not None:
115
for rev in revision:
116
if rev is None:
117
raise BzrCommandError('You cannot specify a NULL revision.')
118
revno, rev_id = rev.in_history(b)
119
sys.stdout.write(b.get_revision_xml_file(rev_id).read())
120
121
122
class cmd_revno(Command):
123
"""Show current revision number.
124
125
This is equal to the number of revisions on this branch."""
126
def run(self):
127
print Branch.open_containing('.').revno()
128
129
130
class cmd_revision_info(Command):
131
"""Show revision number and revision id for a given revision identifier.
132
"""
133
hidden = True
134
takes_args = ['revision_info*']
135
takes_options = ['revision']
136
def run(self, revision=None, revision_info_list=[]):
137
from bzrlib.revisionspec import RevisionSpec
138
139
revs = []
140
if revision is not None:
141
revs.extend(revision)
142
if revision_info_list is not None:
143
for rev in revision_info_list:
144
revs.append(RevisionSpec(rev))
145
if len(revs) == 0:
146
raise BzrCommandError('You must supply a revision identifier')
147
148
b = Branch.open_containing('.')
149
150
for rev in revs:
151
revinfo = rev.in_history(b)
152
if revinfo.revno is None:
153
print ' %s' % revinfo.rev_id
154
else:
155
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
156
157
158
class cmd_add(Command):
159
"""Add specified files or directories.
160
161
In non-recursive mode, all the named items are added, regardless
162
of whether they were previously ignored. A warning is given if
163
any of the named files are already versioned.
164
165
In recursive mode (the default), files are treated the same way
166
but the behaviour for directories is different. Directories that
167
are already versioned do not give a warning. All directories,
168
whether already versioned or not, are searched for files or
169
subdirectories that are neither versioned or ignored, and these
170
are added. This search proceeds recursively into versioned
171
directories. If no names are given '.' is assumed.
172
173
Therefore simply saying 'bzr add' will version all files that
174
are currently unknown.
175
176
Adding a file whose parent directory is not versioned will
177
implicitly add the parent, and so on up to the root. This means
178
you should never need to explictly add a directory, they'll just
179
get added when you add a file in the directory.
180
"""
181
takes_args = ['file*']
182
takes_options = ['no-recurse', 'quiet']
183
184
def run(self, file_list, no_recurse=False, quiet=False):
185
from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
186
if quiet:
187
reporter = add_reporter_null
188
else:
189
reporter = add_reporter_print
190
smart_add(file_list, not no_recurse, reporter)
191
192
193
class cmd_mkdir(Command):
194
"""Create a new versioned directory.
195
196
This is equivalent to creating the directory and then adding it.
197
"""
198
takes_args = ['dir+']
199
200
def run(self, dir_list):
201
b = None
202
203
for d in dir_list:
204
os.mkdir(d)
205
if not b:
206
b = Branch.open_containing(d)
207
b.add([d])
208
print 'added', d
209
210
211
class cmd_relpath(Command):
212
"""Show path of a file relative to root"""
213
takes_args = ['filename']
214
hidden = True
215
216
def run(self, filename):
217
print Branch.open_containing(filename).relpath(filename)
218
219
220
221
class cmd_inventory(Command):
222
"""Show inventory of the current working copy or a revision."""
223
takes_options = ['revision', 'show-ids']
224
225
def run(self, revision=None, show_ids=False):
226
b = Branch.open_containing('.')
227
if revision is None:
228
inv = b.read_working_inventory()
229
else:
230
if len(revision) > 1:
231
raise BzrCommandError('bzr inventory --revision takes'
232
' exactly one revision identifier')
233
inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
234
235
for path, entry in inv.entries():
236
if show_ids:
237
print '%-50s %s' % (path, entry.file_id)
238
else:
239
print path
240
241
242
class cmd_move(Command):
243
"""Move files to a different directory.
244
245
examples:
246
bzr move *.txt doc
247
248
The destination must be a versioned directory in the same branch.
249
"""
250
takes_args = ['source$', 'dest']
251
def run(self, source_list, dest):
252
b = Branch.open_containing('.')
253
254
# TODO: glob expansion on windows?
255
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
256
257
258
class cmd_rename(Command):
259
"""Change the name of an entry.
260
261
examples:
262
bzr rename frob.c frobber.c
263
bzr rename src/frob.c lib/frob.c
264
265
It is an error if the destination name exists.
266
267
See also the 'move' command, which moves files into a different
268
directory without changing their name.
269
"""
270
# TODO: Some way to rename multiple files without invoking
271
# bzr for each one?"""
272
takes_args = ['from_name', 'to_name']
273
274
def run(self, from_name, to_name):
275
b = Branch.open_containing('.')
276
b.rename_one(b.relpath(from_name), b.relpath(to_name))
277
278
279
280
class cmd_mv(Command):
281
"""Move or rename a file.
282
283
usage:
284
bzr mv OLDNAME NEWNAME
285
bzr mv SOURCE... DESTINATION
286
287
If the last argument is a versioned directory, all the other names
288
are moved into it. Otherwise, there must be exactly two arguments
289
and the file is changed to a new name, which must not already exist.
290
291
Files cannot be moved between branches.
292
"""
293
takes_args = ['names*']
294
def run(self, names_list):
295
if len(names_list) < 2:
296
raise BzrCommandError("missing file argument")
297
b = Branch.open_containing(names_list[0])
298
299
rel_names = [b.relpath(x) for x in names_list]
300
301
if os.path.isdir(names_list[-1]):
302
# move into existing directory
303
for pair in b.move(rel_names[:-1], rel_names[-1]):
304
print "%s => %s" % pair
305
else:
306
if len(names_list) != 2:
307
raise BzrCommandError('to mv multiple files the destination '
308
'must be a versioned directory')
309
b.rename_one(rel_names[0], rel_names[1])
310
print "%s => %s" % (rel_names[0], rel_names[1])
311
312
313
314
315
class cmd_pull(Command):
316
"""Pull any changes from another branch into the current one.
317
318
If the location is omitted, the last-used location will be used.
319
Both the revision history and the working directory will be
320
updated.
321
322
This command only works on branches that have not diverged. Branches are
323
considered diverged if both branches have had commits without first
324
pulling from the other.
325
326
If branches have diverged, you can use 'bzr merge' to pull the text changes
327
from one into the other.
328
"""
329
takes_options = ['remember']
330
takes_args = ['location?']
331
332
def run(self, location=None, remember=False):
333
from bzrlib.merge import merge
334
import tempfile
335
from shutil import rmtree
336
import errno
337
338
br_to = Branch.open_containing('.')
339
stored_loc = br_to.get_parent()
340
if location is None:
341
if stored_loc is None:
342
raise BzrCommandError("No pull location known or specified.")
343
else:
344
print "Using saved location: %s" % stored_loc
345
location = stored_loc
346
cache_root = tempfile.mkdtemp()
347
br_from = Branch.open(location)
348
br_from.lock_read()
349
try:
350
br_from.setup_caching(cache_root)
351
location = br_from.base
352
old_revno = br_to.revno()
353
old_revision_history = br_to.revision_history()
354
try:
355
br_to.update_revisions(br_from)
356
except DivergedBranches:
357
raise BzrCommandError("These branches have diverged."
358
" Try merge.")
359
new_revision_history = br_to.revision_history()
360
if new_revision_history != old_revision_history:
361
merge(('.', -1), ('.', old_revno), check_clean=False)
362
if stored_loc is None or remember:
363
br_to.set_parent(location)
364
finally:
365
br_from.unlock()
366
rmtree(cache_root)
367
368
369
370
class cmd_branch(Command):
371
"""Create a new copy of a branch.
372
373
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
374
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
375
376
To retrieve the branch as of a particular revision, supply the --revision
377
parameter, as in "branch foo/bar -r 5".
378
379
--basis is to speed up branching from remote branches. When specified, it
380
copies all the file-contents, inventory and revision data from the basis
381
branch before copying anything from the remote branch.
382
"""
383
takes_args = ['from_location', 'to_location?']
384
takes_options = ['revision', 'basis']
385
aliases = ['get', 'clone']
386
387
def run(self, from_location, to_location=None, revision=None, basis=None):
388
from bzrlib.clone import copy_branch
389
import tempfile
390
import errno
391
from shutil import rmtree
392
cache_root = tempfile.mkdtemp()
393
if revision is None:
394
revision = [None]
395
elif len(revision) > 1:
396
raise BzrCommandError(
397
'bzr branch --revision takes exactly 1 revision value')
398
try:
399
br_from = Branch.open(from_location)
400
except OSError, e:
401
if e.errno == errno.ENOENT:
402
raise BzrCommandError('Source location "%s" does not'
403
' exist.' % to_location)
404
else:
405
raise
406
br_from.lock_read()
407
try:
408
br_from.setup_caching(cache_root)
409
if basis is not None:
410
basis_branch = Branch.open_containing(basis)
411
else:
412
basis_branch = None
413
if len(revision) == 1 and revision[0] is not None:
414
revision_id = revision[0].in_history(br_from)[1]
415
else:
416
revision_id = None
417
if to_location is None:
418
to_location = os.path.basename(from_location.rstrip("/\\"))
419
try:
420
os.mkdir(to_location)
421
except OSError, e:
422
if e.errno == errno.EEXIST:
423
raise BzrCommandError('Target directory "%s" already'
424
' exists.' % to_location)
425
if e.errno == errno.ENOENT:
426
raise BzrCommandError('Parent of "%s" does not exist.' %
427
to_location)
428
else:
429
raise
430
try:
431
copy_branch(br_from, to_location, revision_id, basis_branch)
432
except bzrlib.errors.NoSuchRevision:
433
rmtree(to_location)
434
msg = "The branch %s has no revision %d." % (from_location, revision[0])
435
raise BzrCommandError(msg)
436
except bzrlib.errors.UnlistableBranch:
437
msg = "The branch %s cannot be used as a --basis"
438
finally:
439
br_from.unlock()
440
rmtree(cache_root)
441
442
443
class cmd_renames(Command):
444
"""Show list of renamed files.
445
"""
446
# TODO: Option to show renames between two historical versions.
447
448
# TODO: Only show renames under dir, rather than in the whole branch.
449
takes_args = ['dir?']
450
451
def run(self, dir='.'):
452
b = Branch.open_containing(dir)
453
old_inv = b.basis_tree().inventory
454
new_inv = b.read_working_inventory()
455
456
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
457
renames.sort()
458
for old_name, new_name in renames:
459
print "%s => %s" % (old_name, new_name)
460
461
462
class cmd_info(Command):
463
"""Show statistical information about a branch."""
464
takes_args = ['branch?']
465
466
def run(self, branch=None):
467
import info
468
b = Branch.open_containing(branch)
469
info.show_info(b)
470
471
472
class cmd_remove(Command):
473
"""Make a file unversioned.
474
475
This makes bzr stop tracking changes to a versioned file. It does
476
not delete the working copy.
477
"""
478
takes_args = ['file+']
479
takes_options = ['verbose']
480
aliases = ['rm']
481
482
def run(self, file_list, verbose=False):
483
b = Branch.open_containing(file_list[0])
484
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
485
486
487
class cmd_file_id(Command):
488
"""Print file_id of a particular file or directory.
489
490
The file_id is assigned when the file is first added and remains the
491
same through all revisions where the file exists, even when it is
492
moved or renamed.
493
"""
494
hidden = True
495
takes_args = ['filename']
496
def run(self, filename):
497
b = Branch.open_containing(filename)
498
i = b.inventory.path2id(b.relpath(filename))
499
if i == None:
500
raise BzrError("%r is not a versioned file" % filename)
501
else:
502
print i
503
504
505
class cmd_file_path(Command):
506
"""Print path of file_ids to a file or directory.
507
508
This prints one line for each directory down to the target,
509
starting at the branch root."""
510
hidden = True
511
takes_args = ['filename']
512
def run(self, filename):
513
b = Branch.open_containing(filename)
514
inv = b.inventory
515
fid = inv.path2id(b.relpath(filename))
516
if fid == None:
517
raise BzrError("%r is not a versioned file" % filename)
518
for fip in inv.get_idpath(fid):
519
print fip
520
521
522
class cmd_revision_history(Command):
523
"""Display list of revision ids on this branch."""
524
hidden = True
525
def run(self):
526
for patchid in Branch.open_containing('.').revision_history():
527
print patchid
528
529
530
class cmd_ancestry(Command):
531
"""List all revisions merged into this branch."""
532
hidden = True
533
def run(self):
534
b = find_branch('.')
535
for revision_id in b.get_ancestry(b.last_revision()):
536
print revision_id
537
538
539
class cmd_directories(Command):
540
"""Display list of versioned directories in this branch."""
541
def run(self):
542
for name, ie in Branch.open_containing('.').read_working_inventory().directories():
543
if name == '':
544
print '.'
545
else:
546
print name
547
548
549
class cmd_init(Command):
550
"""Make a directory into a versioned branch.
551
552
Use this to create an empty branch, or before importing an
553
existing project.
554
555
Recipe for importing a tree of files:
556
cd ~/project
557
bzr init
558
bzr add -v .
559
bzr status
560
bzr commit -m 'imported project'
561
"""
562
def run(self):
563
Branch.initialize('.')
564
565
566
class cmd_diff(Command):
567
"""Show differences in working tree.
568
569
If files are listed, only the changes in those files are listed.
570
Otherwise, all changes for the tree are listed.
571
572
examples:
573
bzr diff
574
bzr diff -r1
575
bzr diff -r1..2
576
"""
577
# TODO: Allow diff across branches.
578
# TODO: Option to use external diff command; could be GNU diff, wdiff,
579
# or a graphical diff.
580
581
# TODO: Python difflib is not exactly the same as unidiff; should
582
# either fix it up or prefer to use an external diff.
583
584
# TODO: If a directory is given, diff everything under that.
585
586
# TODO: Selected-file diff is inefficient and doesn't show you
587
# deleted files.
588
589
# TODO: This probably handles non-Unix newlines poorly.
590
591
takes_args = ['file*']
592
takes_options = ['revision', 'diff-options']
593
aliases = ['di', 'dif']
594
595
def run(self, revision=None, file_list=None, diff_options=None):
596
from bzrlib.diff import show_diff
597
598
if file_list:
599
b = Branch.open_containing(file_list[0])
600
file_list = [b.relpath(f) for f in file_list]
601
if file_list == ['']:
602
# just pointing to top-of-tree
603
file_list = None
604
else:
605
b = Branch.open_containing('.')
606
607
if revision is not None:
608
if len(revision) == 1:
609
show_diff(b, revision[0], specific_files=file_list,
610
external_diff_options=diff_options)
611
elif len(revision) == 2:
612
show_diff(b, revision[0], specific_files=file_list,
613
external_diff_options=diff_options,
614
revision2=revision[1])
615
else:
616
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
617
else:
618
show_diff(b, None, specific_files=file_list,
619
external_diff_options=diff_options)
620
621
622
623
624
class cmd_deleted(Command):
625
"""List files deleted in the working tree.
626
"""
627
# TODO: Show files deleted since a previous revision, or
628
# between two revisions.
629
# TODO: Much more efficient way to do this: read in new
630
# directories with readdir, rather than stating each one. Same
631
# level of effort but possibly much less IO. (Or possibly not,
632
# if the directories are very large...)
633
def run(self, show_ids=False):
634
b = Branch.open_containing('.')
635
old = b.basis_tree()
636
new = b.working_tree()
637
for path, ie in old.inventory.iter_entries():
638
if not new.has_id(ie.file_id):
639
if show_ids:
640
print '%-50s %s' % (path, ie.file_id)
641
else:
642
print path
643
644
645
class cmd_modified(Command):
646
"""List files modified in working tree."""
647
hidden = True
648
def run(self):
649
from bzrlib.delta import compare_trees
650
651
b = Branch.open_containing('.')
652
td = compare_trees(b.basis_tree(), b.working_tree())
653
654
for path, id, kind, text_modified, meta_modified in td.modified:
655
print path
656
657
658
659
class cmd_added(Command):
660
"""List files added in working tree."""
661
hidden = True
662
def run(self):
663
b = Branch.open_containing('.')
664
wt = b.working_tree()
665
basis_inv = b.basis_tree().inventory
666
inv = wt.inventory
667
for file_id in inv:
668
if file_id in basis_inv:
669
continue
670
path = inv.id2path(file_id)
671
if not os.access(b.abspath(path), os.F_OK):
672
continue
673
print path
674
675
676
677
class cmd_root(Command):
678
"""Show the tree root directory.
679
680
The root is the nearest enclosing directory with a .bzr control
681
directory."""
682
takes_args = ['filename?']
683
def run(self, filename=None):
684
"""Print the branch root."""
685
b = Branch.open_containing(filename)
686
print b.base
687
688
689
class cmd_log(Command):
690
"""Show log of this branch.
691
692
To request a range of logs, you can use the command -r begin:end
693
-r revision requests a specific revision, -r :end or -r begin: are
694
also valid.
695
696
--message allows you to give a regular expression, which will be evaluated
697
so that only matching entries will be displayed.
698
"""
699
700
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
701
702
takes_args = ['filename?']
703
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
704
'long', 'message', 'short',]
705
706
def run(self, filename=None, timezone='original',
707
verbose=False,
708
show_ids=False,
709
forward=False,
710
revision=None,
711
message=None,
712
long=False,
713
short=False):
714
from bzrlib.log import log_formatter, show_log
715
import codecs
716
717
direction = (forward and 'forward') or 'reverse'
718
719
if filename:
720
b = Branch.open_containing(filename)
721
fp = b.relpath(filename)
722
if fp:
723
file_id = b.read_working_inventory().path2id(fp)
724
else:
725
file_id = None # points to branch root
726
else:
727
b = Branch.open_containing('.')
728
file_id = None
729
730
if revision is None:
731
rev1 = None
732
rev2 = None
733
elif len(revision) == 1:
734
rev1 = rev2 = revision[0].in_history(b).revno
735
elif len(revision) == 2:
736
rev1 = revision[0].in_history(b).revno
737
rev2 = revision[1].in_history(b).revno
738
else:
739
raise BzrCommandError('bzr log --revision takes one or two values.')
740
741
if rev1 == 0:
742
rev1 = None
743
if rev2 == 0:
744
rev2 = None
745
746
mutter('encoding log as %r' % bzrlib.user_encoding)
747
748
# use 'replace' so that we don't abort if trying to write out
749
# in e.g. the default C locale.
750
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
751
752
if not short:
753
log_format = 'long'
754
else:
755
log_format = 'short'
756
lf = log_formatter(log_format,
757
show_ids=show_ids,
758
to_file=outf,
759
show_timezone=timezone)
760
761
show_log(b,
762
lf,
763
file_id,
764
verbose=verbose,
765
direction=direction,
766
start_revision=rev1,
767
end_revision=rev2,
768
search=message)
769
770
771
772
class cmd_touching_revisions(Command):
773
"""Return revision-ids which affected a particular file.
774
775
A more user-friendly interface is "bzr log FILE"."""
776
hidden = True
777
takes_args = ["filename"]
778
def run(self, filename):
779
b = Branch.open_containing(filename)
780
inv = b.read_working_inventory()
781
file_id = inv.path2id(b.relpath(filename))
782
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
783
print "%6d %s" % (revno, what)
784
785
786
class cmd_ls(Command):
787
"""List files in a tree.
788
"""
789
# TODO: Take a revision or remote path and list that tree instead.
790
hidden = True
791
def run(self, revision=None, verbose=False):
792
b = Branch.open_containing('.')
793
if revision == None:
794
tree = b.working_tree()
795
else:
796
tree = b.revision_tree(revision.in_history(b).rev_id)
797
for fp, fc, kind, fid, entry in tree.list_files():
798
if verbose:
799
kindch = entry.kind_character()
800
print '%-8s %s%s' % (fc, fp, kindch)
801
else:
802
print fp
803
804
805
806
class cmd_unknowns(Command):
807
"""List unknown files."""
808
def run(self):
809
from bzrlib.osutils import quotefn
810
for f in Branch.open_containing('.').unknowns():
811
print quotefn(f)
812
813
814
815
class cmd_ignore(Command):
816
"""Ignore a command or pattern.
817
818
To remove patterns from the ignore list, edit the .bzrignore file.
819
820
If the pattern contains a slash, it is compared to the whole path
821
from the branch root. Otherwise, it is compared to only the last
822
component of the path. To match a file only in the root directory,
823
prepend './'.
824
825
Ignore patterns are case-insensitive on case-insensitive systems.
826
827
Note: wildcards must be quoted from the shell on Unix.
828
829
examples:
830
bzr ignore ./Makefile
831
bzr ignore '*.class'
832
"""
833
# TODO: Complain if the filename is absolute
834
takes_args = ['name_pattern']
835
836
def run(self, name_pattern):
837
from bzrlib.atomicfile import AtomicFile
838
import os.path
839
840
b = Branch.open_containing('.')
841
ifn = b.abspath('.bzrignore')
842
843
if os.path.exists(ifn):
844
f = open(ifn, 'rt')
845
try:
846
igns = f.read().decode('utf-8')
847
finally:
848
f.close()
849
else:
850
igns = ''
851
852
# TODO: If the file already uses crlf-style termination, maybe
853
# we should use that for the newly added lines?
854
855
if igns and igns[-1] != '\n':
856
igns += '\n'
857
igns += name_pattern + '\n'
858
859
try:
860
f = AtomicFile(ifn, 'wt')
861
f.write(igns.encode('utf-8'))
862
f.commit()
863
finally:
864
f.close()
865
866
inv = b.working_tree().inventory
867
if inv.path2id('.bzrignore'):
868
mutter('.bzrignore is already versioned')
869
else:
870
mutter('need to make new .bzrignore file versioned')
871
b.add(['.bzrignore'])
872
873
874
875
class cmd_ignored(Command):
876
"""List ignored files and the patterns that matched them.
877
878
See also: bzr ignore"""
879
def run(self):
880
tree = Branch.open_containing('.').working_tree()
881
for path, file_class, kind, file_id, entry in tree.list_files():
882
if file_class != 'I':
883
continue
884
## XXX: Slightly inefficient since this was already calculated
885
pat = tree.is_ignored(path)
886
print '%-50s %s' % (path, pat)
887
888
889
class cmd_lookup_revision(Command):
890
"""Lookup the revision-id from a revision-number
891
892
example:
893
bzr lookup-revision 33
894
"""
895
hidden = True
896
takes_args = ['revno']
897
898
def run(self, revno):
899
try:
900
revno = int(revno)
901
except ValueError:
902
raise BzrCommandError("not a valid revision-number: %r" % revno)
903
904
print Branch.open_containing('.').get_rev_id(revno)
905
906
907
class cmd_export(Command):
908
"""Export past revision to destination directory.
909
910
If no revision is specified this exports the last committed revision.
911
912
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
913
given, try to find the format with the extension. If no extension
914
is found exports to a directory (equivalent to --format=dir).
915
916
Root may be the top directory for tar, tgz and tbz2 formats. If none
917
is given, the top directory will be the root name of the file."""
918
# TODO: list known exporters
919
takes_args = ['dest']
920
takes_options = ['revision', 'format', 'root']
921
def run(self, dest, revision=None, format=None, root=None):
922
import os.path
923
b = Branch.open_containing('.')
924
if revision is None:
925
rev_id = b.last_revision()
926
else:
927
if len(revision) != 1:
928
raise BzrError('bzr export --revision takes exactly 1 argument')
929
rev_id = revision[0].in_history(b).rev_id
930
t = b.revision_tree(rev_id)
931
arg_root, ext = os.path.splitext(os.path.basename(dest))
932
if ext in ('.gz', '.bz2'):
933
new_root, new_ext = os.path.splitext(arg_root)
934
if new_ext == '.tar':
935
arg_root = new_root
936
ext = new_ext + ext
937
if root is None:
938
root = arg_root
939
if not format:
940
if ext in (".tar",):
941
format = "tar"
942
elif ext in (".tar.gz", ".tgz"):
943
format = "tgz"
944
elif ext in (".tar.bz2", ".tbz2"):
945
format = "tbz2"
946
else:
947
format = "dir"
948
t.export(dest, format, root)
949
950
951
class cmd_cat(Command):
952
"""Write a file's text from a previous revision."""
953
954
takes_options = ['revision']
955
takes_args = ['filename']
956
957
def run(self, filename, revision=None):
958
if revision is None:
959
raise BzrCommandError("bzr cat requires a revision number")
960
elif len(revision) != 1:
961
raise BzrCommandError("bzr cat --revision takes exactly one number")
962
b = Branch.open_containing('.')
963
b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
964
965
966
class cmd_local_time_offset(Command):
967
"""Show the offset in seconds from GMT to local time."""
968
hidden = True
969
def run(self):
970
print bzrlib.osutils.local_time_offset()
971
972
973
974
class cmd_commit(Command):
975
"""Commit changes into a new revision.
976
977
If no arguments are given, the entire tree is committed.
978
979
If selected files are specified, only changes to those files are
980
committed. If a directory is specified then the directory and everything
981
within it is committed.
982
983
A selected-file commit may fail in some cases where the committed
984
tree would be invalid, such as trying to commit a file in a
985
newly-added directory that is not itself committed.
986
"""
987
# TODO: Run hooks on tree to-be-committed, and after commit.
988
989
# TODO: Strict commit that fails if there are unknown or deleted files.
990
# TODO: Give better message for -s, --summary, used by tla people
991
992
# XXX: verbose currently does nothing
993
994
takes_args = ['selected*']
995
takes_options = ['message', 'file', 'verbose', 'unchanged']
996
aliases = ['ci', 'checkin']
997
998
def run(self, message=None, file=None, verbose=True, selected_list=None,
999
unchanged=False):
1000
from bzrlib.errors import PointlessCommit, ConflictsInTree
1001
from bzrlib.msgeditor import edit_commit_message
1002
from bzrlib.status import show_status
1003
from cStringIO import StringIO
1004
1005
b = Branch.open_containing('.')
1006
if selected_list:
1007
selected_list = [b.relpath(s) for s in selected_list]
1008
1009
1010
if message is None and not file:
1011
catcher = StringIO()
1012
show_status(b, specific_files=selected_list,
1013
to_file=catcher)
1014
message = edit_commit_message(catcher.getvalue())
1015
1016
if message is None:
1017
raise BzrCommandError("please specify a commit message"
1018
" with either --message or --file")
1019
elif message and file:
1020
raise BzrCommandError("please specify either --message or --file")
1021
1022
if file:
1023
import codecs
1024
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1025
1026
if message == "":
1027
raise BzrCommandError("empty commit message specified")
1028
1029
try:
1030
b.commit(message,
1031
specific_files=selected_list,
1032
allow_pointless=unchanged)
1033
except PointlessCommit:
1034
# FIXME: This should really happen before the file is read in;
1035
# perhaps prepare the commit; get the message; then actually commit
1036
raise BzrCommandError("no changes to commit",
1037
["use --unchanged to commit anyhow"])
1038
except ConflictsInTree:
1039
raise BzrCommandError("Conflicts detected in working tree. "
1040
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1041
1042
1043
class cmd_check(Command):
1044
"""Validate consistency of branch history.
1045
1046
This command checks various invariants about the branch storage to
1047
detect data corruption or bzr bugs.
1048
"""
1049
takes_args = ['dir?']
1050
1051
def run(self, dir='.'):
1052
from bzrlib.check import check
1053
1054
check(Branch.open_containing(dir))
1055
1056
1057
class cmd_scan_cache(Command):
1058
hidden = True
1059
def run(self):
1060
from bzrlib.hashcache import HashCache
1061
1062
c = HashCache('.')
1063
c.read()
1064
c.scan()
1065
1066
print '%6d stats' % c.stat_count
1067
print '%6d in hashcache' % len(c._cache)
1068
print '%6d files removed from cache' % c.removed_count
1069
print '%6d hashes updated' % c.update_count
1070
print '%6d files changed too recently to cache' % c.danger_count
1071
1072
if c.needs_write:
1073
c.write()
1074
1075
1076
1077
class cmd_upgrade(Command):
1078
"""Upgrade branch storage to current format.
1079
1080
The check command or bzr developers may sometimes advise you to run
1081
this command.
1082
1083
This version of this command upgrades from the full-text storage
1084
used by bzr 0.0.8 and earlier to the weave format (v5).
1085
"""
1086
takes_args = ['dir?']
1087
1088
def run(self, dir='.'):
1089
from bzrlib.upgrade import upgrade
1090
upgrade(dir)
1091
1092
1093
class cmd_whoami(Command):
1094
"""Show bzr user id."""
1095
takes_options = ['email']
1096
1097
def run(self, email=False):
1098
try:
1099
b = bzrlib.branch.Branch.open_containing('.')
1100
except NotBranchError:
1101
b = None
1102
1103
if email:
1104
print bzrlib.config.user_email(b)
1105
else:
1106
print bzrlib.config.username(b)
1107
1108
1109
class cmd_selftest(Command):
1110
"""Run internal test suite.
1111
1112
This creates temporary test directories in the working directory,
1113
but not existing data is affected. These directories are deleted
1114
if the tests pass, or left behind to help in debugging if they
1115
fail.
1116
1117
If arguments are given, they are regular expressions that say
1118
which tests should run."""
1119
# TODO: --list should give a list of all available tests
1120
hidden = True
1121
takes_args = ['testspecs*']
1122
takes_options = ['verbose']
1123
def run(self, testspecs_list=None, verbose=False):
1124
import bzrlib.ui
1125
from bzrlib.selftest import selftest
1126
# we don't want progress meters from the tests to go to the
1127
# real output; and we don't want log messages cluttering up
1128
# the real logs.
1129
save_ui = bzrlib.ui.ui_factory
1130
bzrlib.trace.info('running tests...')
1131
try:
1132
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1133
if testspecs_list is not None:
1134
pattern = '|'.join(testspecs_list)
1135
else:
1136
pattern = ".*"
1137
result = selftest(verbose=verbose,
1138
pattern=pattern)
1139
if result:
1140
bzrlib.trace.info('tests passed')
1141
else:
1142
bzrlib.trace.info('tests failed')
1143
return int(not result)
1144
finally:
1145
bzrlib.ui.ui_factory = save_ui
1146
1147
1148
def show_version():
1149
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1150
# is bzrlib itself in a branch?
1151
bzrrev = bzrlib.get_bzr_revision()
1152
if bzrrev:
1153
print " (bzr checkout, revision %d {%s})" % bzrrev
1154
print bzrlib.__copyright__
1155
print "http://bazaar-ng.org/"
1156
print
1157
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1158
print "you may use, modify and redistribute it under the terms of the GNU"
1159
print "General Public License version 2 or later."
1160
1161
1162
class cmd_version(Command):
1163
"""Show version of bzr."""
1164
def run(self):
1165
show_version()
1166
1167
class cmd_rocks(Command):
1168
"""Statement of optimism."""
1169
hidden = True
1170
def run(self):
1171
print "it sure does!"
1172
1173
1174
class cmd_find_merge_base(Command):
1175
"""Find and print a base revision for merging two branches.
1176
"""
1177
# TODO: Options to specify revisions on either side, as if
1178
# merging only part of the history.
1179
takes_args = ['branch', 'other']
1180
hidden = True
1181
1182
def run(self, branch, other):
1183
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1184
1185
branch1 = Branch.open_containing(branch)
1186
branch2 = Branch.open_containing(other)
1187
1188
history_1 = branch1.revision_history()
1189
history_2 = branch2.revision_history()
1190
1191
last1 = branch1.last_revision()
1192
last2 = branch2.last_revision()
1193
1194
source = MultipleRevisionSources(branch1, branch2)
1195
1196
base_rev_id = common_ancestor(last1, last2, source)
1197
1198
print 'merge base is revision %s' % base_rev_id
1199
1200
return
1201
1202
if base_revno is None:
1203
raise bzrlib.errors.UnrelatedBranches()
1204
1205
print ' r%-6d in %s' % (base_revno, branch)
1206
1207
other_revno = branch2.revision_id_to_revno(base_revid)
1208
1209
print ' r%-6d in %s' % (other_revno, other)
1210
1211
1212
1213
class cmd_merge(Command):
1214
"""Perform a three-way merge.
1215
1216
The branch is the branch you will merge from. By default, it will
1217
merge the latest revision. If you specify a revision, that
1218
revision will be merged. If you specify two revisions, the first
1219
will be used as a BASE, and the second one as OTHER. Revision
1220
numbers are always relative to the specified branch.
1221
1222
By default bzr will try to merge in all new work from the other
1223
branch, automatically determining an appropriate base. If this
1224
fails, you may need to give an explicit base.
1225
1226
Examples:
1227
1228
To merge the latest revision from bzr.dev
1229
bzr merge ../bzr.dev
1230
1231
To merge changes up to and including revision 82 from bzr.dev
1232
bzr merge -r 82 ../bzr.dev
1233
1234
To merge the changes introduced by 82, without previous changes:
1235
bzr merge -r 81..82 ../bzr.dev
1236
1237
merge refuses to run if there are any uncommitted changes, unless
1238
--force is given.
1239
"""
1240
takes_args = ['branch?']
1241
takes_options = ['revision', 'force', 'merge-type']
1242
1243
def run(self, branch=None, revision=None, force=False,
1244
merge_type=None):
1245
from bzrlib.merge import merge
1246
from bzrlib.merge_core import ApplyMerge3
1247
if merge_type is None:
1248
merge_type = ApplyMerge3
1249
if branch is None:
1250
branch = Branch.open_containing('.').get_parent()
1251
if branch is None:
1252
raise BzrCommandError("No merge location known or specified.")
1253
else:
1254
print "Using saved location: %s" % branch
1255
if revision is None or len(revision) < 1:
1256
base = [None, None]
1257
other = [branch, -1]
1258
else:
1259
if len(revision) == 1:
1260
base = [None, None]
1261
other = [branch, revision[0].in_history(branch).revno]
1262
else:
1263
assert len(revision) == 2
1264
if None in revision:
1265
raise BzrCommandError(
1266
"Merge doesn't permit that revision specifier.")
1267
b = Branch.open(branch)
1268
1269
base = [branch, revision[0].in_history(b).revno]
1270
other = [branch, revision[1].in_history(b).revno]
1271
1272
try:
1273
merge(other, base, check_clean=(not force), merge_type=merge_type)
1274
except bzrlib.errors.AmbiguousBase, e:
1275
m = ("sorry, bzr can't determine the right merge base yet\n"
1276
"candidates are:\n "
1277
+ "\n ".join(e.bases)
1278
+ "\n"
1279
"please specify an explicit base with -r,\n"
1280
"and (if you want) report this to the bzr developers\n")
1281
log_error(m)
1282
1283
1284
class cmd_revert(Command):
1285
"""Reverse all changes since the last commit.
1286
1287
Only versioned files are affected. Specify filenames to revert only
1288
those files. By default, any files that are changed will be backed up
1289
first. Backup files have a '~' appended to their name.
1290
"""
1291
takes_options = ['revision', 'no-backup']
1292
takes_args = ['file*']
1293
aliases = ['merge-revert']
1294
1295
def run(self, revision=None, no_backup=False, file_list=None):
1296
from bzrlib.merge import merge
1297
from bzrlib.commands import parse_spec
1298
1299
if file_list is not None:
1300
if len(file_list) == 0:
1301
raise BzrCommandError("No files specified")
1302
if revision is None:
1303
revno = -1
1304
elif len(revision) != 1:
1305
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1306
else:
1307
b = Branch.open_containing('.')
1308
revno = revision[0].in_history(b).revno
1309
merge(('.', revno), parse_spec('.'),
1310
check_clean=False,
1311
ignore_zero=True,
1312
backup_files=not no_backup,
1313
file_list=file_list)
1314
if not file_list:
1315
Branch.open_containing('.').set_pending_merges([])
1316
1317
1318
class cmd_assert_fail(Command):
1319
"""Test reporting of assertion failures"""
1320
hidden = True
1321
def run(self):
1322
assert False, "always fails"
1323
1324
1325
class cmd_help(Command):
1326
"""Show help on a command or other topic.
1327
1328
For a list of all available commands, say 'bzr help commands'."""
1329
takes_options = ['long']
1330
takes_args = ['topic?']
1331
aliases = ['?']
1332
1333
def run(self, topic=None, long=False):
1334
import help
1335
if topic is None and long:
1336
topic = "commands"
1337
help.help(topic)
1338
1339
1340
class cmd_shell_complete(Command):
1341
"""Show appropriate completions for context.
1342
1343
For a list of all available commands, say 'bzr shell-complete'."""
1344
takes_args = ['context?']
1345
aliases = ['s-c']
1346
hidden = True
1347
1348
def run(self, context=None):
1349
import shellcomplete
1350
shellcomplete.shellcomplete(context)
1351
1352
1353
class cmd_fetch(Command):
1354
"""Copy in history from another branch but don't merge it.
1355
1356
This is an internal method used for pull and merge."""
1357
hidden = True
1358
takes_args = ['from_branch', 'to_branch']
1359
def run(self, from_branch, to_branch):
1360
from bzrlib.fetch import Fetcher
1361
from bzrlib.branch import Branch
1362
from_b = Branch(from_branch)
1363
to_b = Branch(to_branch)
1364
Fetcher(to_b, from_b)
1365
1366
1367
1368
class cmd_missing(Command):
1369
"""What is missing in this branch relative to other branch.
1370
"""
1371
# TODO: rewrite this in terms of ancestry so that it shows only
1372
# unmerged things
1373
1374
takes_args = ['remote?']
1375
aliases = ['mis', 'miss']
1376
# We don't have to add quiet to the list, because
1377
# unknown options are parsed as booleans
1378
takes_options = ['verbose', 'quiet']
1379
1380
def run(self, remote=None, verbose=False, quiet=False):
1381
from bzrlib.errors import BzrCommandError
1382
from bzrlib.missing import show_missing
1383
1384
if verbose and quiet:
1385
raise BzrCommandError('Cannot pass both quiet and verbose')
1386
1387
b = Branch.open_containing('.')
1388
parent = b.get_parent()
1389
if remote is None:
1390
if parent is None:
1391
raise BzrCommandError("No missing location known or specified.")
1392
else:
1393
if not quiet:
1394
print "Using last location: %s" % parent
1395
remote = parent
1396
elif parent is None:
1397
# We only update parent if it did not exist, missing
1398
# should not change the parent
1399
b.set_parent(remote)
1400
br_remote = Branch.open_containing(remote)
1401
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1402
1403
1404
class cmd_plugins(Command):
1405
"""List plugins"""
1406
hidden = True
1407
def run(self):
1408
import bzrlib.plugin
1409
from inspect import getdoc
1410
for plugin in bzrlib.plugin.all_plugins:
1411
if hasattr(plugin, '__path__'):
1412
print plugin.__path__[0]
1413
elif hasattr(plugin, '__file__'):
1414
print plugin.__file__
1415
else:
1416
print `plugin`
1417
1418
d = getdoc(plugin)
1419
if d:
1420
print '\t', d.split('\n')[0]
1421
1422
1423
class cmd_testament(Command):
1424
"""Show testament (signing-form) of a revision."""
1425
takes_options = ['revision', 'long']
1426
takes_args = ['branch?']
1427
def run(self, branch='.', revision=None, long=False):
1428
from bzrlib.testament import Testament
1429
b = Branch.open_containing(branch)
1430
b.lock_read()
1431
try:
1432
if revision is None:
1433
rev_id = b.last_revision()
1434
else:
1435
rev_id = revision[0].in_history(b).rev_id
1436
t = Testament.from_revision(b, rev_id)
1437
if long:
1438
sys.stdout.writelines(t.as_text_lines())
1439
else:
1440
sys.stdout.write(t.as_short_text())
1441
finally:
1442
b.unlock()
1443
1444
1445
class cmd_annotate(Command):
1446
"""Show the origin of each line in a file.
1447
1448
This prints out the given file with an annotation on the
1449
left side indicating which revision, author and date introduced the
1450
change.
1451
"""
1452
# TODO: annotate directories; showing when each file was last changed
1453
# TODO: annotate a previous version of a file
1454
aliases = ['blame', 'praise']
1455
takes_args = ['filename']
1456
1457
def run(self, filename):
1458
from bzrlib.annotate import annotate_file
1459
b = Branch.open_containing(filename)
1460
b.lock_read()
1461
try:
1462
rp = b.relpath(filename)
1463
tree = b.revision_tree(b.last_revision())
1464
file_id = tree.inventory.path2id(rp)
1465
file_version = tree.inventory[file_id].revision
1466
annotate_file(b, file_version, file_id, sys.stdout)
1467
finally:
1468
b.unlock()
1469
1470
# these get imported and then picked up by the scan for cmd_*
1471
# TODO: Some more consistent way to split command definitions across files;
1472
# we do need to load at least some information about them to know of
1473
# aliases.
1474
from bzrlib.conflicts import cmd_resolve, cmd_conflicts
Loggerhead is a web-based interface for Breezy
Version: 2.0.1