« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1417.1.12
- compare with another revision
- download diff
- download tarball
- view history from revision 1417.1.12
- Committer: Robert Collins
- Date: 2005-10-11 02:41:25 UTC
- mto: This revision was merged to the branch mainline in revision 1438.
- Revision ID: robertc@robertcollins.net-20051011024125-4e05fd2ffc83c965
cache revision history during read transactions
- files added:
- .rsyncexclude
- 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
- patches
- tools
- files removed:
- bzrlib/tests.py
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- files modified:
- .bzrignore
- bzr *
- setup.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.branch import Branch
26
from bzrlib import BZRDIR
27
from bzrlib.commands import Command
28
29
30
class cmd_status(Command):
31
"""Display status summary.
32
33
This reports on versioned and unknown files, reporting them
34
grouped by state. Possible states are:
35
36
added
37
Versioned in the working copy but not in the previous revision.
38
39
removed
40
Versioned in the previous revision but removed or deleted
41
in the working copy.
42
43
renamed
44
Path of this file changed from the previous revision;
45
the text may also have changed. This includes files whose
46
parent directory was renamed.
47
48
modified
49
Text has changed since the previous revision.
50
51
unchanged
52
Nothing about this file has changed since the previous revision.
53
Only shown with --all.
54
55
unknown
56
Not versioned and not matching an ignore pattern.
57
58
To see ignored files use 'bzr ignored'. For details in the
59
changes to file texts, use 'bzr diff'.
60
61
If no arguments are specified, the status of the entire working
62
directory is shown. Otherwise, only the status of the specified
63
files or directories is reported. If a directory is given, status
64
is reported for everything inside that directory.
65
66
If a revision argument is given, the status is calculated against
67
that revision, or between two revisions if two are provided.
68
"""
69
# XXX: FIXME: bzr status should accept a -r option to show changes
70
# relative to a revision, or between revisions
71
72
takes_args = ['file*']
73
takes_options = ['all', 'show-ids']
74
aliases = ['st', 'stat']
75
76
def run(self, all=False, show_ids=False, file_list=None, revision=None):
77
if file_list:
78
b = Branch.open_containing(file_list[0])
79
file_list = [b.relpath(x) for x in file_list]
80
# special case: only one path was given and it's the root
81
# of the branch
82
if file_list == ['']:
83
file_list = None
84
else:
85
b = Branch.open_containing('.')
86
87
from bzrlib.status import show_status
88
show_status(b, show_unchanged=all, show_ids=show_ids,
89
specific_files=file_list, revision=revision)
90
91
92
class cmd_cat_revision(Command):
93
"""Write out metadata for a revision.
94
95
The revision to print can either be specified by a specific
96
revision identifier, or you can use --revision.
97
"""
98
99
hidden = True
100
takes_args = ['revision_id?']
101
takes_options = ['revision']
102
103
def run(self, revision_id=None, revision=None):
104
from bzrlib.revisionspec import RevisionSpec
105
106
if revision_id is not None and revision is not None:
107
raise BzrCommandError('You can only supply one of revision_id or --revision')
108
if revision_id is None and revision is None:
109
raise BzrCommandError('You must supply either --revision or a revision_id')
110
b = Branch.open_containing('.')
111
if revision_id is not None:
112
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
113
elif revision is not None:
114
for rev in revision:
115
if rev is None:
116
raise BzrCommandError('You cannot specify a NULL revision.')
117
revno, rev_id = rev.in_history(b)
118
sys.stdout.write(b.get_revision_xml_file(rev_id).read())
119
120
121
class cmd_revno(Command):
122
"""Show current revision number.
123
124
This is equal to the number of revisions on this branch."""
125
def run(self):
126
print Branch.open_containing('.').revno()
127
128
129
class cmd_revision_info(Command):
130
"""Show revision number and revision id for a given revision identifier.
131
"""
132
hidden = True
133
takes_args = ['revision_info*']
134
takes_options = ['revision']
135
def run(self, revision=None, revision_info_list=[]):
136
from bzrlib.revisionspec import RevisionSpec
137
138
revs = []
139
if revision is not None:
140
revs.extend(revision)
141
if revision_info_list is not None:
142
for rev in revision_info_list:
143
revs.append(RevisionSpec(rev))
144
if len(revs) == 0:
145
raise BzrCommandError('You must supply a revision identifier')
146
147
b = Branch.open_containing('.')
148
149
for rev in revs:
150
revinfo = rev.in_history(b)
151
if revinfo.revno is None:
152
print ' %s' % revinfo.rev_id
153
else:
154
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
155
156
157
class cmd_add(Command):
158
"""Add specified files or directories.
159
160
In non-recursive mode, all the named items are added, regardless
161
of whether they were previously ignored. A warning is given if
162
any of the named files are already versioned.
163
164
In recursive mode (the default), files are treated the same way
165
but the behaviour for directories is different. Directories that
166
are already versioned do not give a warning. All directories,
167
whether already versioned or not, are searched for files or
168
subdirectories that are neither versioned or ignored, and these
169
are added. This search proceeds recursively into versioned
170
directories. If no names are given '.' is assumed.
171
172
Therefore simply saying 'bzr add' will version all files that
173
are currently unknown.
174
175
Adding a file whose parent directory is not versioned will
176
implicitly add the parent, and so on up to the root. This means
177
you should never need to explictly add a directory, they'll just
178
get added when you add a file in the directory.
179
"""
180
takes_args = ['file*']
181
takes_options = ['verbose', 'no-recurse']
182
183
def run(self, file_list, verbose=False, no_recurse=False):
184
# verbose currently has no effect
185
from bzrlib.add import smart_add, add_reporter_print
186
smart_add(file_list, not no_recurse, add_reporter_print)
187
188
189
190
class cmd_mkdir(Command):
191
"""Create a new versioned directory.
192
193
This is equivalent to creating the directory and then adding it.
194
"""
195
takes_args = ['dir+']
196
197
def run(self, dir_list):
198
b = None
199
200
for d in dir_list:
201
os.mkdir(d)
202
if not b:
203
b = Branch.open_containing(d)
204
b.add([d])
205
print 'added', d
206
207
208
class cmd_relpath(Command):
209
"""Show path of a file relative to root"""
210
takes_args = ['filename']
211
hidden = True
212
213
def run(self, filename):
214
print Branch.open_containing(filename).relpath(filename)
215
216
217
218
class cmd_inventory(Command):
219
"""Show inventory of the current working copy or a revision."""
220
takes_options = ['revision', 'show-ids']
221
222
def run(self, revision=None, show_ids=False):
223
b = Branch.open_containing('.')
224
if revision is None:
225
inv = b.read_working_inventory()
226
else:
227
if len(revision) > 1:
228
raise BzrCommandError('bzr inventory --revision takes'
229
' exactly one revision identifier')
230
inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
231
232
for path, entry in inv.entries():
233
if show_ids:
234
print '%-50s %s' % (path, entry.file_id)
235
else:
236
print path
237
238
239
class cmd_move(Command):
240
"""Move files to a different directory.
241
242
examples:
243
bzr move *.txt doc
244
245
The destination must be a versioned directory in the same branch.
246
"""
247
takes_args = ['source$', 'dest']
248
def run(self, source_list, dest):
249
b = Branch.open_containing('.')
250
251
# TODO: glob expansion on windows?
252
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
253
254
255
class cmd_rename(Command):
256
"""Change the name of an entry.
257
258
examples:
259
bzr rename frob.c frobber.c
260
bzr rename src/frob.c lib/frob.c
261
262
It is an error if the destination name exists.
263
264
See also the 'move' command, which moves files into a different
265
directory without changing their name.
266
267
TODO: Some way to rename multiple files without invoking bzr for each
268
one?"""
269
takes_args = ['from_name', 'to_name']
270
271
def run(self, from_name, to_name):
272
b = Branch.open_containing('.')
273
b.rename_one(b.relpath(from_name), b.relpath(to_name))
274
275
276
277
class cmd_mv(Command):
278
"""Move or rename a file.
279
280
usage:
281
bzr mv OLDNAME NEWNAME
282
bzr mv SOURCE... DESTINATION
283
284
If the last argument is a versioned directory, all the other names
285
are moved into it. Otherwise, there must be exactly two arguments
286
and the file is changed to a new name, which must not already exist.
287
288
Files cannot be moved between branches.
289
"""
290
takes_args = ['names*']
291
def run(self, names_list):
292
if len(names_list) < 2:
293
raise BzrCommandError("missing file argument")
294
b = Branch.open_containing(names_list[0])
295
296
rel_names = [b.relpath(x) for x in names_list]
297
298
if os.path.isdir(names_list[-1]):
299
# move into existing directory
300
for pair in b.move(rel_names[:-1], rel_names[-1]):
301
print "%s => %s" % pair
302
else:
303
if len(names_list) != 2:
304
raise BzrCommandError('to mv multiple files the destination '
305
'must be a versioned directory')
306
b.rename_one(rel_names[0], rel_names[1])
307
print "%s => %s" % (rel_names[0], rel_names[1])
308
309
310
311
312
class cmd_pull(Command):
313
"""Pull any changes from another branch into the current one.
314
315
If the location is omitted, the last-used location will be used.
316
Both the revision history and the working directory will be
317
updated.
318
319
This command only works on branches that have not diverged. Branches are
320
considered diverged if both branches have had commits without first
321
pulling from the other.
322
323
If branches have diverged, you can use 'bzr merge' to pull the text changes
324
from one into the other.
325
"""
326
takes_options = ['remember']
327
takes_args = ['location?']
328
329
def run(self, location=None, remember=False):
330
from bzrlib.merge import merge
331
import tempfile
332
from shutil import rmtree
333
import errno
334
335
br_to = Branch.open_containing('.')
336
stored_loc = br_to.get_parent()
337
if location is None:
338
if stored_loc is None:
339
raise BzrCommandError("No pull location known or specified.")
340
else:
341
print "Using saved location: %s" % stored_loc
342
location = stored_loc
343
cache_root = tempfile.mkdtemp()
344
from bzrlib.errors import DivergedBranches
345
br_from = Branch.open_containing(location)
346
location = br_from.base
347
old_revno = br_to.revno()
348
try:
349
from bzrlib.errors import DivergedBranches
350
br_from = Branch.open(location)
351
br_from.setup_caching(cache_root)
352
location = br_from.base
353
old_revno = br_to.revno()
354
try:
355
br_to.update_revisions(br_from)
356
except DivergedBranches:
357
raise BzrCommandError("These branches have diverged."
358
" Try merge.")
359
360
merge(('.', -1), ('.', old_revno), check_clean=False)
361
if stored_loc is None or remember:
362
br_to.set_parent(location)
363
finally:
364
rmtree(cache_root)
365
366
367
368
class cmd_branch(Command):
369
"""Create a new copy of a branch.
370
371
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
372
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
373
374
To retrieve the branch as of a particular revision, supply the --revision
375
parameter, as in "branch foo/bar -r 5".
376
377
--basis is to speed up branching from remote branches. When specified, it
378
copies all the file-contents, inventory and revision data from the basis
379
branch before copying anything from the remote branch.
380
"""
381
takes_args = ['from_location', 'to_location?']
382
takes_options = ['revision', 'basis']
383
aliases = ['get', 'clone']
384
385
def run(self, from_location, to_location=None, revision=None, basis=None):
386
from bzrlib.clone import copy_branch
387
import tempfile
388
import errno
389
from shutil import rmtree
390
cache_root = tempfile.mkdtemp()
391
try:
392
if revision is None:
393
revision = [None]
394
elif len(revision) > 1:
395
raise BzrCommandError(
396
'bzr branch --revision takes exactly 1 revision value')
397
try:
398
br_from = Branch.open(from_location)
399
except OSError, e:
400
if e.errno == errno.ENOENT:
401
raise BzrCommandError('Source location "%s" does not'
402
' exist.' % to_location)
403
else:
404
raise
405
br_from.setup_caching(cache_root)
406
if basis is not None:
407
basis_branch = Branch.open_containing(basis)
408
else:
409
basis_branch = None
410
if len(revision) == 1 and revision[0] is not None:
411
revision_id = revision[0].in_history(br_from)[1]
412
else:
413
revision_id = None
414
if to_location is None:
415
to_location = os.path.basename(from_location.rstrip("/\\"))
416
try:
417
os.mkdir(to_location)
418
except OSError, e:
419
if e.errno == errno.EEXIST:
420
raise BzrCommandError('Target directory "%s" already'
421
' exists.' % to_location)
422
if e.errno == errno.ENOENT:
423
raise BzrCommandError('Parent of "%s" does not exist.' %
424
to_location)
425
else:
426
raise
427
try:
428
copy_branch(br_from, to_location, revision_id, basis_branch)
429
except bzrlib.errors.NoSuchRevision:
430
rmtree(to_location)
431
msg = "The branch %s has no revision %d." % (from_location, revision[0])
432
raise BzrCommandError(msg)
433
except bzrlib.errors.UnlistableBranch:
434
msg = "The branch %s cannot be used as a --basis"
435
finally:
436
rmtree(cache_root)
437
438
439
class cmd_renames(Command):
440
"""Show list of renamed files.
441
442
TODO: Option to show renames between two historical versions.
443
444
TODO: Only show renames under dir, rather than in the whole branch.
445
"""
446
takes_args = ['dir?']
447
448
def run(self, dir='.'):
449
b = Branch.open_containing(dir)
450
old_inv = b.basis_tree().inventory
451
new_inv = b.read_working_inventory()
452
453
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
454
renames.sort()
455
for old_name, new_name in renames:
456
print "%s => %s" % (old_name, new_name)
457
458
459
class cmd_info(Command):
460
"""Show statistical information about a branch."""
461
takes_args = ['branch?']
462
463
def run(self, branch=None):
464
import info
465
466
b = Branch.open_containing(branch)
467
info.show_info(b)
468
469
470
class cmd_remove(Command):
471
"""Make a file unversioned.
472
473
This makes bzr stop tracking changes to a versioned file. It does
474
not delete the working copy.
475
"""
476
takes_args = ['file+']
477
takes_options = ['verbose']
478
aliases = ['rm']
479
480
def run(self, file_list, verbose=False):
481
b = Branch.open_containing(file_list[0])
482
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
483
484
485
class cmd_file_id(Command):
486
"""Print file_id of a particular file or directory.
487
488
The file_id is assigned when the file is first added and remains the
489
same through all revisions where the file exists, even when it is
490
moved or renamed.
491
"""
492
hidden = True
493
takes_args = ['filename']
494
def run(self, filename):
495
b = Branch.open_containing(filename)
496
i = b.inventory.path2id(b.relpath(filename))
497
if i == None:
498
raise BzrError("%r is not a versioned file" % filename)
499
else:
500
print i
501
502
503
class cmd_file_path(Command):
504
"""Print path of file_ids to a file or directory.
505
506
This prints one line for each directory down to the target,
507
starting at the branch root."""
508
hidden = True
509
takes_args = ['filename']
510
def run(self, filename):
511
b = Branch.open_containing(filename)
512
inv = b.inventory
513
fid = inv.path2id(b.relpath(filename))
514
if fid == None:
515
raise BzrError("%r is not a versioned file" % filename)
516
for fip in inv.get_idpath(fid):
517
print fip
518
519
520
class cmd_revision_history(Command):
521
"""Display list of revision ids on this branch."""
522
hidden = True
523
def run(self):
524
for patchid in Branch.open_containing('.').revision_history():
525
print patchid
526
527
528
class cmd_ancestry(Command):
529
"""List all revisions merged into this branch."""
530
hidden = True
531
def run(self):
532
b = find_branch('.')
533
for revision_id in b.get_ancestry(b.last_revision()):
534
print revision_id
535
536
537
class cmd_directories(Command):
538
"""Display list of versioned directories in this branch."""
539
def run(self):
540
for name, ie in Branch.open_containing('.').read_working_inventory().directories():
541
if name == '':
542
print '.'
543
else:
544
print name
545
546
547
class cmd_init(Command):
548
"""Make a directory into a versioned branch.
549
550
Use this to create an empty branch, or before importing an
551
existing project.
552
553
Recipe for importing a tree of files:
554
cd ~/project
555
bzr init
556
bzr add -v .
557
bzr status
558
bzr commit -m 'imported project'
559
"""
560
def run(self):
561
Branch.initialize('.')
562
563
564
class cmd_diff(Command):
565
"""Show differences in working tree.
566
567
If files are listed, only the changes in those files are listed.
568
Otherwise, all changes for the tree are listed.
569
570
TODO: Allow diff across branches.
571
572
TODO: Option to use external diff command; could be GNU diff, wdiff,
573
or a graphical diff.
574
575
TODO: Python difflib is not exactly the same as unidiff; should
576
either fix it up or prefer to use an external diff.
577
578
TODO: If a directory is given, diff everything under that.
579
580
TODO: Selected-file diff is inefficient and doesn't show you
581
deleted files.
582
583
TODO: This probably handles non-Unix newlines poorly.
584
585
examples:
586
bzr diff
587
bzr diff -r1
588
bzr diff -r1..2
589
"""
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 between two revisions.
628
"""
629
def run(self, show_ids=False):
630
b = Branch.open_containing('.')
631
old = b.basis_tree()
632
new = b.working_tree()
633
634
## TODO: Much more efficient way to do this: read in new
635
## directories with readdir, rather than stating each one. Same
636
## level of effort but possibly much less IO. (Or possibly not,
637
## if the directories are very large...)
638
639
for path, ie in old.inventory.iter_entries():
640
if not new.has_id(ie.file_id):
641
if show_ids:
642
print '%-50s %s' % (path, ie.file_id)
643
else:
644
print path
645
646
647
class cmd_modified(Command):
648
"""List files modified in working tree."""
649
hidden = True
650
def run(self):
651
from bzrlib.delta import compare_trees
652
653
b = Branch.open_containing('.')
654
td = compare_trees(b.basis_tree(), b.working_tree())
655
656
for path, id, kind, text_modified, meta_modified in td.modified:
657
print path
658
659
660
661
class cmd_added(Command):
662
"""List files added in working tree."""
663
hidden = True
664
def run(self):
665
b = Branch.open_containing('.')
666
wt = b.working_tree()
667
basis_inv = b.basis_tree().inventory
668
inv = wt.inventory
669
for file_id in inv:
670
if file_id in basis_inv:
671
continue
672
path = inv.id2path(file_id)
673
if not os.access(b.abspath(path), os.F_OK):
674
continue
675
print path
676
677
678
679
class cmd_root(Command):
680
"""Show the tree root directory.
681
682
The root is the nearest enclosing directory with a .bzr control
683
directory."""
684
takes_args = ['filename?']
685
def run(self, filename=None):
686
"""Print the branch root."""
687
b = Branch.open_containing(filename)
688
print b.base
689
690
691
class cmd_log(Command):
692
"""Show log of this branch.
693
694
To request a range of logs, you can use the command -r begin:end
695
-r revision requests a specific revision, -r :end or -r begin: are
696
also valid.
697
698
--message allows you to give a regular expression, which will be evaluated
699
so that only matching entries will be displayed.
700
"""
701
702
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
703
704
takes_args = ['filename?']
705
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
706
'long', 'message', 'short',]
707
708
def run(self, filename=None, timezone='original',
709
verbose=False,
710
show_ids=False,
711
forward=False,
712
revision=None,
713
message=None,
714
long=False,
715
short=False):
716
from bzrlib.log import log_formatter, show_log
717
import codecs
718
719
direction = (forward and 'forward') or 'reverse'
720
721
if filename:
722
b = Branch.open_containing(filename)
723
fp = b.relpath(filename)
724
if fp:
725
file_id = b.read_working_inventory().path2id(fp)
726
else:
727
file_id = None # points to branch root
728
else:
729
b = Branch.open_containing('.')
730
file_id = None
731
732
if revision is None:
733
rev1 = None
734
rev2 = None
735
elif len(revision) == 1:
736
rev1 = rev2 = revision[0].in_history(b).revno
737
elif len(revision) == 2:
738
rev1 = revision[0].in_history(b).revno
739
rev2 = revision[1].in_history(b).revno
740
else:
741
raise BzrCommandError('bzr log --revision takes one or two values.')
742
743
if rev1 == 0:
744
rev1 = None
745
if rev2 == 0:
746
rev2 = None
747
748
mutter('encoding log as %r' % bzrlib.user_encoding)
749
750
# use 'replace' so that we don't abort if trying to write out
751
# in e.g. the default C locale.
752
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
753
754
if not short:
755
log_format = 'long'
756
else:
757
log_format = 'short'
758
lf = log_formatter(log_format,
759
show_ids=show_ids,
760
to_file=outf,
761
show_timezone=timezone)
762
763
show_log(b,
764
lf,
765
file_id,
766
verbose=verbose,
767
direction=direction,
768
start_revision=rev1,
769
end_revision=rev2,
770
search=message)
771
772
773
774
class cmd_touching_revisions(Command):
775
"""Return revision-ids which affected a particular file.
776
777
A more user-friendly interface is "bzr log FILE"."""
778
hidden = True
779
takes_args = ["filename"]
780
def run(self, filename):
781
b = Branch.open_containing(filename)
782
inv = b.read_working_inventory()
783
file_id = inv.path2id(b.relpath(filename))
784
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
785
print "%6d %s" % (revno, what)
786
787
788
class cmd_ls(Command):
789
"""List files in a tree.
790
791
TODO: Take a revision or remote path and list that tree instead.
792
"""
793
hidden = True
794
def run(self, revision=None, verbose=False):
795
b = Branch.open_containing('.')
796
if revision == None:
797
tree = b.working_tree()
798
else:
799
tree = b.revision_tree(revision.in_history(b).rev_id)
800
for fp, fc, kind, fid, entry in tree.list_files():
801
if verbose:
802
kindch = entry.kind_character()
803
print '%-8s %s%s' % (fc, fp, kindch)
804
else:
805
print fp
806
807
808
809
class cmd_unknowns(Command):
810
"""List unknown files."""
811
def run(self):
812
from bzrlib.osutils import quotefn
813
for f in Branch.open_containing('.').unknowns():
814
print quotefn(f)
815
816
817
818
class cmd_ignore(Command):
819
"""Ignore a command or pattern.
820
821
To remove patterns from the ignore list, edit the .bzrignore file.
822
823
If the pattern contains a slash, it is compared to the whole path
824
from the branch root. Otherwise, it is comapred to only the last
825
component of the path.
826
827
Ignore patterns are case-insensitive on case-insensitive systems.
828
829
Note: wildcards must be quoted from the shell on Unix.
830
831
examples:
832
bzr ignore ./Makefile
833
bzr ignore '*.class'
834
"""
835
takes_args = ['name_pattern']
836
837
def run(self, name_pattern):
838
from bzrlib.atomicfile import AtomicFile
839
import os.path
840
841
b = Branch.open_containing('.')
842
ifn = b.abspath('.bzrignore')
843
844
if os.path.exists(ifn):
845
f = open(ifn, 'rt')
846
try:
847
igns = f.read().decode('utf-8')
848
finally:
849
f.close()
850
else:
851
igns = ''
852
853
# TODO: If the file already uses crlf-style termination, maybe
854
# we should use that for the newly added lines?
855
856
if igns and igns[-1] != '\n':
857
igns += '\n'
858
igns += name_pattern + '\n'
859
860
try:
861
f = AtomicFile(ifn, 'wt')
862
f.write(igns.encode('utf-8'))
863
f.commit()
864
finally:
865
f.close()
866
867
inv = b.working_tree().inventory
868
if inv.path2id('.bzrignore'):
869
mutter('.bzrignore is already versioned')
870
else:
871
mutter('need to make new .bzrignore file versioned')
872
b.add(['.bzrignore'])
873
874
875
876
class cmd_ignored(Command):
877
"""List ignored files and the patterns that matched them.
878
879
See also: bzr ignore"""
880
def run(self):
881
tree = Branch.open_containing('.').working_tree()
882
for path, file_class, kind, file_id, entry in tree.list_files():
883
if file_class != 'I':
884
continue
885
## XXX: Slightly inefficient since this was already calculated
886
pat = tree.is_ignored(path)
887
print '%-50s %s' % (path, pat)
888
889
890
class cmd_lookup_revision(Command):
891
"""Lookup the revision-id from a revision-number
892
893
example:
894
bzr lookup-revision 33
895
"""
896
hidden = True
897
takes_args = ['revno']
898
899
def run(self, revno):
900
try:
901
revno = int(revno)
902
except ValueError:
903
raise BzrCommandError("not a valid revision-number: %r" % revno)
904
905
print Branch.open_containing('.').get_rev_id(revno)
906
907
908
class cmd_export(Command):
909
"""Export past revision to destination directory.
910
911
If no revision is specified this exports the last committed revision.
912
913
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
914
given, try to find the format with the extension. If no extension
915
is found exports to a directory (equivalent to --format=dir).
916
917
Root may be the top directory for tar, tgz and tbz2 formats. If none
918
is given, the top directory will be the root name of the file."""
919
# TODO: list known exporters
920
takes_args = ['dest']
921
takes_options = ['revision', 'format', 'root']
922
def run(self, dest, revision=None, format=None, root=None):
923
import os.path
924
b = Branch.open_containing('.')
925
if revision is None:
926
rev_id = b.last_revision()
927
else:
928
if len(revision) != 1:
929
raise BzrError('bzr export --revision takes exactly 1 argument')
930
rev_id = revision[0].in_history(b).rev_id
931
t = b.revision_tree(rev_id)
932
arg_root, ext = os.path.splitext(os.path.basename(dest))
933
if ext in ('.gz', '.bz2'):
934
new_root, new_ext = os.path.splitext(arg_root)
935
if new_ext == '.tar':
936
arg_root = new_root
937
ext = new_ext + ext
938
if root is None:
939
root = arg_root
940
if not format:
941
if ext in (".tar",):
942
format = "tar"
943
elif ext in (".tar.gz", ".tgz"):
944
format = "tgz"
945
elif ext in (".tar.bz2", ".tbz2"):
946
format = "tbz2"
947
else:
948
format = "dir"
949
t.export(dest, format, root)
950
951
952
class cmd_cat(Command):
953
"""Write a file's text from a previous revision."""
954
955
takes_options = ['revision']
956
takes_args = ['filename']
957
958
def run(self, filename, revision=None):
959
if revision is None:
960
raise BzrCommandError("bzr cat requires a revision number")
961
elif len(revision) != 1:
962
raise BzrCommandError("bzr cat --revision takes exactly one number")
963
b = Branch.open_containing('.')
964
b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
965
966
967
class cmd_local_time_offset(Command):
968
"""Show the offset in seconds from GMT to local time."""
969
hidden = True
970
def run(self):
971
print bzrlib.osutils.local_time_offset()
972
973
974
975
class cmd_commit(Command):
976
"""Commit changes into a new revision.
977
978
If no arguments are given, the entire tree is committed.
979
980
If selected files are specified, only changes to those files are
981
committed. If a directory is specified then the directory and everything
982
within it is committed.
983
984
A selected-file commit may fail in some cases where the committed
985
tree would be invalid, such as trying to commit a file in a
986
newly-added directory that is not itself committed.
987
988
TODO: Run hooks on tree to-be-committed, and after commit.
989
990
TODO: Strict commit that fails if there are unknown or deleted files.
991
"""
992
takes_args = ['selected*']
993
takes_options = ['message', 'file', 'verbose', 'unchanged']
994
aliases = ['ci', 'checkin']
995
996
# TODO: Give better message for -s, --summary, used by tla people
997
998
# XXX: verbose currently does nothing
999
1000
def run(self, message=None, file=None, verbose=True, selected_list=None,
1001
unchanged=False):
1002
from bzrlib.errors import PointlessCommit, ConflictsInTree
1003
from bzrlib.msgeditor import edit_commit_message
1004
from bzrlib.status import show_status
1005
from cStringIO import StringIO
1006
1007
b = Branch.open_containing('.')
1008
if selected_list:
1009
selected_list = [b.relpath(s) for s in selected_list]
1010
1011
1012
if message is None and not file:
1013
catcher = StringIO()
1014
show_status(b, specific_files=selected_list,
1015
to_file=catcher)
1016
message = edit_commit_message(catcher.getvalue())
1017
1018
if message is None:
1019
raise BzrCommandError("please specify a commit message"
1020
" with either --message or --file")
1021
elif message and file:
1022
raise BzrCommandError("please specify either --message or --file")
1023
1024
if file:
1025
import codecs
1026
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1027
1028
if message == "":
1029
raise BzrCommandError("empty commit message specified")
1030
1031
try:
1032
b.commit(message,
1033
specific_files=selected_list,
1034
allow_pointless=unchanged)
1035
except PointlessCommit:
1036
# FIXME: This should really happen before the file is read in;
1037
# perhaps prepare the commit; get the message; then actually commit
1038
raise BzrCommandError("no changes to commit",
1039
["use --unchanged to commit anyhow"])
1040
except ConflictsInTree:
1041
raise BzrCommandError("Conflicts detected in working tree. "
1042
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1043
1044
1045
class cmd_check(Command):
1046
"""Validate consistency of branch history.
1047
1048
This command checks various invariants about the branch storage to
1049
detect data corruption or bzr bugs.
1050
"""
1051
takes_args = ['dir?']
1052
1053
def run(self, dir='.'):
1054
from bzrlib.check import check
1055
1056
check(Branch.open_containing(dir))
1057
1058
1059
class cmd_scan_cache(Command):
1060
hidden = True
1061
def run(self):
1062
from bzrlib.hashcache import HashCache
1063
1064
c = HashCache('.')
1065
c.read()
1066
c.scan()
1067
1068
print '%6d stats' % c.stat_count
1069
print '%6d in hashcache' % len(c._cache)
1070
print '%6d files removed from cache' % c.removed_count
1071
print '%6d hashes updated' % c.update_count
1072
print '%6d files changed too recently to cache' % c.danger_count
1073
1074
if c.needs_write:
1075
c.write()
1076
1077
1078
1079
class cmd_upgrade(Command):
1080
"""Upgrade branch storage to current format.
1081
1082
The check command or bzr developers may sometimes advise you to run
1083
this command.
1084
1085
This version of this command upgrades from the full-text storage
1086
used by bzr 0.0.8 and earlier to the weave format (v5).
1087
"""
1088
takes_args = ['dir?']
1089
1090
def run(self, dir='.'):
1091
from bzrlib.upgrade import upgrade
1092
upgrade(dir)
1093
1094
1095
class cmd_whoami(Command):
1096
"""Show bzr user id."""
1097
takes_options = ['email']
1098
1099
def run(self, email=False):
1100
try:
1101
b = bzrlib.branch.Branch.open_containing('.')
1102
except NotBranchError:
1103
b = None
1104
1105
if email:
1106
print bzrlib.osutils.user_email(b)
1107
else:
1108
print bzrlib.osutils.username(b)
1109
1110
1111
class cmd_selftest(Command):
1112
"""Run internal test suite.
1113
1114
This creates temporary test directories in the working directory,
1115
but not existing data is affected. These directories are deleted
1116
if the tests pass, or left behind to help in debugging if they
1117
fail.
1118
1119
If arguments are given, they are regular expressions that say
1120
which tests should run."""
1121
# TODO: --list should give a list of all available tests
1122
hidden = True
1123
takes_args = ['testnames*']
1124
takes_options = ['verbose', 'pattern']
1125
def run(self, testnames_list=None, verbose=False, pattern=".*"):
1126
import bzrlib.ui
1127
from bzrlib.selftest import selftest
1128
# we don't want progress meters from the tests to go to the
1129
# real output; and we don't want log messages cluttering up
1130
# the real logs.
1131
save_ui = bzrlib.ui.ui_factory
1132
bzrlib.trace.info('running tests...')
1133
try:
1134
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1135
result = selftest(verbose=verbose,
1136
pattern=pattern,
1137
testnames=testnames_list)
1138
if result:
1139
bzrlib.trace.info('tests passed')
1140
else:
1141
bzrlib.trace.info('tests failed')
1142
return int(not result)
1143
finally:
1144
bzrlib.ui.ui_factory = save_ui
1145
1146
1147
def show_version():
1148
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1149
# is bzrlib itself in a branch?
1150
bzrrev = bzrlib.get_bzr_revision()
1151
if bzrrev:
1152
print " (bzr checkout, revision %d {%s})" % bzrrev
1153
print bzrlib.__copyright__
1154
print "http://bazaar-ng.org/"
1155
print
1156
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1157
print "you may use, modify and redistribute it under the terms of the GNU"
1158
print "General Public License version 2 or later."
1159
1160
1161
class cmd_version(Command):
1162
"""Show version of bzr."""
1163
def run(self):
1164
show_version()
1165
1166
class cmd_rocks(Command):
1167
"""Statement of optimism."""
1168
hidden = True
1169
def run(self):
1170
print "it sure does!"
1171
1172
1173
class cmd_find_merge_base(Command):
1174
"""Find and print a base revision for merging two branches.
1175
1176
TODO: Options to specify revisions on either side, as if
1177
merging only part of the history.
1178
"""
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
Loggerhead is a web-based interface for Breezy
Version: 2.0.1