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