« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 334
- compare with another revision
- download diff
- download tarball
- view history from revision 334
- Committer: Martin Pool
- Date: 2005-05-03 08:00:27 UTC
- Revision ID: mbp@sourcefrog.net-20050503080027-908edb5b39982198
doc
- files added:
- bzrlib/tests.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- patches
- tools
- files renamed:
- contrib/bash/bzr.simple => contrib/bash/bzr
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- 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 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', 'revision']
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_args = ['location?']
327
328
def run(self, location=None):
329
from bzrlib.merge import merge
330
import tempfile
331
from shutil import rmtree
332
import errno
333
334
br_to = Branch.open_containing('.')
335
stored_loc = br_to.get_parent()
336
if location is None:
337
if stored_loc is None:
338
raise BzrCommandError("No pull location known or specified.")
339
else:
340
print "Using last location: %s" % stored_loc
341
location = stored_loc
342
cache_root = tempfile.mkdtemp()
343
from bzrlib.errors import DivergedBranches
344
br_from = Branch.open_containing(location)
345
location = br_from.base
346
old_revno = br_to.revno()
347
try:
348
from bzrlib.errors import DivergedBranches
349
br_from = Branch.open(location)
350
br_from.setup_caching(cache_root)
351
location = br_from.base
352
old_revno = br_to.revno()
353
try:
354
br_to.update_revisions(br_from)
355
except DivergedBranches:
356
raise BzrCommandError("These branches have diverged."
357
" Try merge.")
358
359
merge(('.', -1), ('.', old_revno), check_clean=False)
360
if location != stored_loc:
361
br_to.set_parent(location)
362
finally:
363
rmtree(cache_root)
364
365
366
367
class cmd_branch(Command):
368
"""Create a new copy of a branch.
369
370
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
371
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
372
373
To retrieve the branch as of a particular revision, supply the --revision
374
parameter, as in "branch foo/bar -r 5".
375
376
--basis is to speed up branching from remote branches. When specified, it
377
copies all the file-contents, inventory and revision data from the basis
378
branch before copying anything from the remote branch.
379
"""
380
takes_args = ['from_location', 'to_location?']
381
takes_options = ['revision', 'basis']
382
aliases = ['get', 'clone']
383
384
def run(self, from_location, to_location=None, revision=None, basis=None):
385
from bzrlib.branch import copy_branch
386
import tempfile
387
import errno
388
from shutil import rmtree
389
cache_root = tempfile.mkdtemp()
390
try:
391
if revision is None:
392
revision = [None]
393
elif len(revision) > 1:
394
raise BzrCommandError(
395
'bzr branch --revision takes exactly 1 revision value')
396
try:
397
br_from = Branch.open(from_location)
398
except OSError, e:
399
if e.errno == errno.ENOENT:
400
raise BzrCommandError('Source location "%s" does not'
401
' exist.' % to_location)
402
else:
403
raise
404
br_from.setup_caching(cache_root)
405
if basis is not None:
406
basis_branch = Branch.open_containing(basis)
407
else:
408
basis_branch = None
409
if len(revision) == 1 and revision[0] is not None:
410
revno = revision[0].in_history(br_from)[0]
411
else:
412
revno = None
413
if to_location is None:
414
to_location = os.path.basename(from_location.rstrip("/\\"))
415
try:
416
os.mkdir(to_location)
417
except OSError, e:
418
if e.errno == errno.EEXIST:
419
raise BzrCommandError('Target directory "%s" already'
420
' exists.' % to_location)
421
if e.errno == errno.ENOENT:
422
raise BzrCommandError('Parent of "%s" does not exist.' %
423
to_location)
424
else:
425
raise
426
try:
427
copy_branch(br_from, to_location, revno, basis_branch)
428
except bzrlib.errors.NoSuchRevision:
429
rmtree(to_location)
430
msg = "The branch %s has no revision %d." % (from_location, revision[0])
431
raise BzrCommandError(msg)
432
except bzrlib.errors.UnlistableBranch:
433
msg = "The branch %s cannot be used as a --basis"
434
finally:
435
rmtree(cache_root)
436
437
438
class cmd_renames(Command):
439
"""Show list of renamed files.
440
441
TODO: Option to show renames between two historical versions.
442
443
TODO: Only show renames under dir, rather than in the whole branch.
444
"""
445
takes_args = ['dir?']
446
447
def run(self, dir='.'):
448
b = Branch.open_containing(dir)
449
old_inv = b.basis_tree().inventory
450
new_inv = b.read_working_inventory()
451
452
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
453
renames.sort()
454
for old_name, new_name in renames:
455
print "%s => %s" % (old_name, new_name)
456
457
458
class cmd_info(Command):
459
"""Show statistical information about a branch."""
460
takes_args = ['branch?']
461
462
def run(self, branch=None):
463
import info
464
465
b = Branch.open_containing(branch)
466
info.show_info(b)
467
468
469
class cmd_remove(Command):
470
"""Make a file unversioned.
471
472
This makes bzr stop tracking changes to a versioned file. It does
473
not delete the working copy.
474
"""
475
takes_args = ['file+']
476
takes_options = ['verbose']
477
478
def run(self, file_list, verbose=False):
479
b = Branch.open_containing(file_list[0])
480
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
481
482
483
class cmd_file_id(Command):
484
"""Print file_id of a particular file or directory.
485
486
The file_id is assigned when the file is first added and remains the
487
same through all revisions where the file exists, even when it is
488
moved or renamed.
489
"""
490
hidden = True
491
takes_args = ['filename']
492
def run(self, filename):
493
b = Branch.open_containing(filename)
494
i = b.inventory.path2id(b.relpath(filename))
495
if i == None:
496
raise BzrError("%r is not a versioned file" % filename)
497
else:
498
print i
499
500
501
class cmd_file_path(Command):
502
"""Print path of file_ids to a file or directory.
503
504
This prints one line for each directory down to the target,
505
starting at the branch root."""
506
hidden = True
507
takes_args = ['filename']
508
def run(self, filename):
509
b = Branch.open_containing(filename)
510
inv = b.inventory
511
fid = inv.path2id(b.relpath(filename))
512
if fid == None:
513
raise BzrError("%r is not a versioned file" % filename)
514
for fip in inv.get_idpath(fid):
515
print fip
516
517
518
class cmd_revision_history(Command):
519
"""Display list of revision ids on this branch."""
520
hidden = True
521
def run(self):
522
for patchid in Branch.open_containing('.').revision_history():
523
print patchid
524
525
526
class cmd_directories(Command):
527
"""Display list of versioned directories in this branch."""
528
def run(self):
529
for name, ie in Branch.open_containing('.').read_working_inventory().directories():
530
if name == '':
531
print '.'
532
else:
533
print name
534
535
536
class cmd_init(Command):
537
"""Make a directory into a versioned branch.
538
539
Use this to create an empty branch, or before importing an
540
existing project.
541
542
Recipe for importing a tree of files:
543
cd ~/project
544
bzr init
545
bzr add -v .
546
bzr status
547
bzr commit -m 'imported project'
548
"""
549
def run(self):
550
from bzrlib.branch import Branch
551
Branch.initialize('.')
552
553
554
class cmd_diff(Command):
555
"""Show differences in working tree.
556
557
If files are listed, only the changes in those files are listed.
558
Otherwise, all changes for the tree are listed.
559
560
TODO: Allow diff across branches.
561
562
TODO: Option to use external diff command; could be GNU diff, wdiff,
563
or a graphical diff.
564
565
TODO: Python difflib is not exactly the same as unidiff; should
566
either fix it up or prefer to use an external diff.
567
568
TODO: If a directory is given, diff everything under that.
569
570
TODO: Selected-file diff is inefficient and doesn't show you
571
deleted files.
572
573
TODO: This probably handles non-Unix newlines poorly.
574
575
examples:
576
bzr diff
577
bzr diff -r1
578
bzr diff -r1..2
579
"""
580
581
takes_args = ['file*']
582
takes_options = ['revision', 'diff-options']
583
aliases = ['di', 'dif']
584
585
def run(self, revision=None, file_list=None, diff_options=None):
586
from bzrlib.diff import show_diff
587
588
if file_list:
589
b = Branch.open_containing(file_list[0])
590
file_list = [b.relpath(f) for f in file_list]
591
if file_list == ['']:
592
# just pointing to top-of-tree
593
file_list = None
594
else:
595
b = Branch.open_containing('.')
596
597
if revision is not None:
598
if len(revision) == 1:
599
show_diff(b, revision[0], specific_files=file_list,
600
external_diff_options=diff_options)
601
elif len(revision) == 2:
602
show_diff(b, revision[0], specific_files=file_list,
603
external_diff_options=diff_options,
604
revision2=revision[1])
605
else:
606
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
607
else:
608
show_diff(b, None, specific_files=file_list,
609
external_diff_options=diff_options)
610
611
612
613
614
class cmd_deleted(Command):
615
"""List files deleted in the working tree.
616
617
TODO: Show files deleted since a previous revision, or between two revisions.
618
"""
619
def run(self, show_ids=False):
620
b = Branch.open_containing('.')
621
old = b.basis_tree()
622
new = b.working_tree()
623
624
## TODO: Much more efficient way to do this: read in new
625
## directories with readdir, rather than stating each one. Same
626
## level of effort but possibly much less IO. (Or possibly not,
627
## if the directories are very large...)
628
629
for path, ie in old.inventory.iter_entries():
630
if not new.has_id(ie.file_id):
631
if show_ids:
632
print '%-50s %s' % (path, ie.file_id)
633
else:
634
print path
635
636
637
class cmd_modified(Command):
638
"""List files modified in working tree."""
639
hidden = True
640
def run(self):
641
from bzrlib.delta import compare_trees
642
643
b = Branch.open_containing('.')
644
td = compare_trees(b.basis_tree(), b.working_tree())
645
646
for path, id, kind in td.modified:
647
print path
648
649
650
651
class cmd_added(Command):
652
"""List files added in working tree."""
653
hidden = True
654
def run(self):
655
b = Branch.open_containing('.')
656
wt = b.working_tree()
657
basis_inv = b.basis_tree().inventory
658
inv = wt.inventory
659
for file_id in inv:
660
if file_id in basis_inv:
661
continue
662
path = inv.id2path(file_id)
663
if not os.access(b.abspath(path), os.F_OK):
664
continue
665
print path
666
667
668
669
class cmd_root(Command):
670
"""Show the tree root directory.
671
672
The root is the nearest enclosing directory with a .bzr control
673
directory."""
674
takes_args = ['filename?']
675
def run(self, filename=None):
676
"""Print the branch root."""
677
b = Branch.open_containing(filename)
678
print b.base
679
680
681
class cmd_log(Command):
682
"""Show log of this branch.
683
684
To request a range of logs, you can use the command -r begin:end
685
-r revision requests a specific revision, -r :end or -r begin: are
686
also valid.
687
688
--message allows you to give a regular expression, which will be evaluated
689
so that only matching entries will be displayed.
690
691
TODO: Make --revision support uuid: and hash: [future tag:] notation.
692
693
"""
694
695
takes_args = ['filename?']
696
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
697
'long', 'message', 'short',]
698
699
def run(self, filename=None, timezone='original',
700
verbose=False,
701
show_ids=False,
702
forward=False,
703
revision=None,
704
message=None,
705
long=False,
706
short=False):
707
from bzrlib.log import log_formatter, show_log
708
import codecs
709
710
direction = (forward and 'forward') or 'reverse'
711
712
if filename:
713
b = Branch.open_containing(filename)
714
fp = b.relpath(filename)
715
if fp:
716
file_id = b.read_working_inventory().path2id(fp)
717
else:
718
file_id = None # points to branch root
719
else:
720
b = Branch.open_containing('.')
721
file_id = None
722
723
if revision is None:
724
rev1 = None
725
rev2 = None
726
elif len(revision) == 1:
727
rev1 = rev2 = revision[0].in_history(b).revno
728
elif len(revision) == 2:
729
rev1 = revision[0].in_history(b).revno
730
rev2 = revision[1].in_history(b).revno
731
else:
732
raise BzrCommandError('bzr log --revision takes one or two values.')
733
734
if rev1 == 0:
735
rev1 = None
736
if rev2 == 0:
737
rev2 = None
738
739
mutter('encoding log as %r' % bzrlib.user_encoding)
740
741
# use 'replace' so that we don't abort if trying to write out
742
# in e.g. the default C locale.
743
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
744
745
if not short:
746
log_format = 'long'
747
else:
748
log_format = 'short'
749
lf = log_formatter(log_format,
750
show_ids=show_ids,
751
to_file=outf,
752
show_timezone=timezone)
753
754
show_log(b,
755
lf,
756
file_id,
757
verbose=verbose,
758
direction=direction,
759
start_revision=rev1,
760
end_revision=rev2,
761
search=message)
762
763
764
765
class cmd_touching_revisions(Command):
766
"""Return revision-ids which affected a particular file.
767
768
A more user-friendly interface is "bzr log FILE"."""
769
hidden = True
770
takes_args = ["filename"]
771
def run(self, filename):
772
b = Branch.open_containing(filename)
773
inv = b.read_working_inventory()
774
file_id = inv.path2id(b.relpath(filename))
775
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
776
print "%6d %s" % (revno, what)
777
778
779
class cmd_ls(Command):
780
"""List files in a tree.
781
782
TODO: Take a revision or remote path and list that tree instead.
783
"""
784
hidden = True
785
def run(self, revision=None, verbose=False):
786
b = Branch.open_containing('.')
787
if revision == None:
788
tree = b.working_tree()
789
else:
790
tree = b.revision_tree(revision.in_history(b).rev_id)
791
792
for fp, fc, kind, fid in tree.list_files():
793
if verbose:
794
if kind == 'directory':
795
kindch = '/'
796
elif kind == 'file':
797
kindch = ''
798
else:
799
kindch = '???'
800
801
print '%-8s %s%s' % (fc, fp, kindch)
802
else:
803
print fp
804
805
806
807
class cmd_unknowns(Command):
808
"""List unknown files."""
809
def run(self):
810
from bzrlib.osutils import quotefn
811
for f in Branch.open_containing('.').unknowns():
812
print quotefn(f)
813
814
815
816
class cmd_ignore(Command):
817
"""Ignore a command or pattern.
818
819
To remove patterns from the ignore list, edit the .bzrignore file.
820
821
If the pattern contains a slash, it is compared to the whole path
822
from the branch root. Otherwise, it is comapred to only the last
823
component of the path.
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
takes_args = ['name_pattern']
834
835
def run(self, name_pattern):
836
from bzrlib.atomicfile import AtomicFile
837
import os.path
838
839
b = Branch.open_containing('.')
840
ifn = b.abspath('.bzrignore')
841
842
if os.path.exists(ifn):
843
f = open(ifn, 'rt')
844
try:
845
igns = f.read().decode('utf-8')
846
finally:
847
f.close()
848
else:
849
igns = ''
850
851
# TODO: If the file already uses crlf-style termination, maybe
852
# we should use that for the newly added lines?
853
854
if igns and igns[-1] != '\n':
855
igns += '\n'
856
igns += name_pattern + '\n'
857
858
try:
859
f = AtomicFile(ifn, 'wt')
860
f.write(igns.encode('utf-8'))
861
f.commit()
862
finally:
863
f.close()
864
865
inv = b.working_tree().inventory
866
if inv.path2id('.bzrignore'):
867
mutter('.bzrignore is already versioned')
868
else:
869
mutter('need to make new .bzrignore file versioned')
870
b.add(['.bzrignore'])
871
872
873
874
class cmd_ignored(Command):
875
"""List ignored files and the patterns that matched them.
876
877
See also: bzr ignore"""
878
def run(self):
879
tree = Branch.open_containing('.').working_tree()
880
for path, file_class, kind, file_id in tree.list_files():
881
if file_class != 'I':
882
continue
883
## XXX: Slightly inefficient since this was already calculated
884
pat = tree.is_ignored(path)
885
print '%-50s %s' % (path, pat)
886
887
888
class cmd_lookup_revision(Command):
889
"""Lookup the revision-id from a revision-number
890
891
example:
892
bzr lookup-revision 33
893
"""
894
hidden = True
895
takes_args = ['revno']
896
897
def run(self, revno):
898
try:
899
revno = int(revno)
900
except ValueError:
901
raise BzrCommandError("not a valid revision-number: %r" % revno)
902
903
print Branch.open_containing('.').get_rev_id(revno)
904
905
906
class cmd_export(Command):
907
"""Export past revision to destination directory.
908
909
If no revision is specified this exports the last committed revision.
910
911
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
912
given, try to find the format with the extension. If no extension
913
is found exports to a directory (equivalent to --format=dir).
914
915
Root may be the top directory for tar, tgz and tbz2 formats. If none
916
is given, the top directory will be the root name of the file."""
917
# TODO: list known exporters
918
takes_args = ['dest']
919
takes_options = ['revision', 'format', 'root']
920
def run(self, dest, revision=None, format=None, root=None):
921
import os.path
922
b = Branch.open_containing('.')
923
if revision is None:
924
rev_id = b.last_patch()
925
else:
926
if len(revision) != 1:
927
raise BzrError('bzr export --revision takes exactly 1 argument')
928
rev_id = revision[0].in_history(b).rev_id
929
t = b.revision_tree(rev_id)
930
root, ext = os.path.splitext(dest)
931
if not format:
932
if ext in (".tar",):
933
format = "tar"
934
elif ext in (".gz", ".tgz"):
935
format = "tgz"
936
elif ext in (".bz2", ".tbz2"):
937
format = "tbz2"
938
else:
939
format = "dir"
940
t.export(dest, format, root)
941
942
943
class cmd_cat(Command):
944
"""Write a file's text from a previous revision."""
945
946
takes_options = ['revision']
947
takes_args = ['filename']
948
949
def run(self, filename, revision=None):
950
if revision is None:
951
raise BzrCommandError("bzr cat requires a revision number")
952
elif len(revision) != 1:
953
raise BzrCommandError("bzr cat --revision takes exactly one number")
954
b = Branch.open_containing('.')
955
b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
956
957
958
class cmd_local_time_offset(Command):
959
"""Show the offset in seconds from GMT to local time."""
960
hidden = True
961
def run(self):
962
print bzrlib.osutils.local_time_offset()
963
964
965
966
class cmd_commit(Command):
967
"""Commit changes into a new revision.
968
969
If no arguments are given, the entire tree is committed.
970
971
If selected files are specified, only changes to those files are
972
committed. If a directory is specified then the directory and everything
973
within it is committed.
974
975
A selected-file commit may fail in some cases where the committed
976
tree would be invalid, such as trying to commit a file in a
977
newly-added directory that is not itself committed.
978
979
TODO: Run hooks on tree to-be-committed, and after commit.
980
981
TODO: Strict commit that fails if there are unknown or deleted files.
982
"""
983
takes_args = ['selected*']
984
takes_options = ['message', 'file', 'verbose', 'unchanged']
985
aliases = ['ci', 'checkin']
986
987
# TODO: Give better message for -s, --summary, used by tla people
988
989
def run(self, message=None, file=None, verbose=True, selected_list=None,
990
unchanged=False):
991
from bzrlib.errors import PointlessCommit
992
from bzrlib.msgeditor import edit_commit_message
993
from bzrlib.status import show_status
994
from cStringIO import StringIO
995
996
b = Branch.open_containing('.')
997
if selected_list:
998
selected_list = [b.relpath(s) for s in selected_list]
999
1000
if not message and not file:
1001
catcher = StringIO()
1002
show_status(b, specific_files=selected_list,
1003
to_file=catcher)
1004
message = edit_commit_message(catcher.getvalue())
1005
1006
if message is None:
1007
raise BzrCommandError("please specify a commit message"
1008
" with either --message or --file")
1009
elif message and file:
1010
raise BzrCommandError("please specify either --message or --file")
1011
1012
if file:
1013
import codecs
1014
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1015
1016
try:
1017
b.commit(message, verbose=verbose,
1018
specific_files=selected_list,
1019
allow_pointless=unchanged)
1020
except PointlessCommit:
1021
# FIXME: This should really happen before the file is read in;
1022
# perhaps prepare the commit; get the message; then actually commit
1023
raise BzrCommandError("no changes to commit",
1024
["use --unchanged to commit anyhow"])
1025
1026
1027
class cmd_check(Command):
1028
"""Validate consistency of branch history.
1029
1030
This command checks various invariants about the branch storage to
1031
detect data corruption or bzr bugs.
1032
"""
1033
takes_args = ['dir?']
1034
1035
def run(self, dir='.'):
1036
from bzrlib.check import check
1037
1038
check(Branch.open_containing(dir))
1039
1040
1041
class cmd_scan_cache(Command):
1042
hidden = True
1043
def run(self):
1044
from bzrlib.hashcache import HashCache
1045
1046
c = HashCache('.')
1047
c.read()
1048
c.scan()
1049
1050
print '%6d stats' % c.stat_count
1051
print '%6d in hashcache' % len(c._cache)
1052
print '%6d files removed from cache' % c.removed_count
1053
print '%6d hashes updated' % c.update_count
1054
print '%6d files changed too recently to cache' % c.danger_count
1055
1056
if c.needs_write:
1057
c.write()
1058
1059
1060
1061
class cmd_upgrade(Command):
1062
"""Upgrade branch storage to current format.
1063
1064
The check command or bzr developers may sometimes advise you to run
1065
this command.
1066
"""
1067
takes_args = ['dir?']
1068
1069
def run(self, dir='.'):
1070
from bzrlib.upgrade import upgrade
1071
upgrade(Branch.open_containing(dir))
1072
1073
1074
1075
class cmd_whoami(Command):
1076
"""Show bzr user id."""
1077
takes_options = ['email']
1078
1079
def run(self, email=False):
1080
try:
1081
b = bzrlib.branch.Branch.open_containing('.')
1082
except:
1083
b = None
1084
1085
if email:
1086
print bzrlib.osutils.user_email(b)
1087
else:
1088
print bzrlib.osutils.username(b)
1089
1090
1091
class cmd_selftest(Command):
1092
"""Run internal test suite"""
1093
hidden = True
1094
takes_options = ['verbose', 'pattern']
1095
def run(self, verbose=False, pattern=".*"):
1096
import bzrlib.ui
1097
from bzrlib.selftest import selftest
1098
# we don't want progress meters from the tests to go to the
1099
# real output; and we don't want log messages cluttering up
1100
# the real logs.
1101
save_ui = bzrlib.ui.ui_factory
1102
bzrlib.trace.info('running tests...')
1103
try:
1104
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1105
result = selftest(verbose=verbose, pattern=pattern)
1106
if result:
1107
bzrlib.trace.info('tests passed')
1108
else:
1109
bzrlib.trace.info('tests failed')
1110
return int(not result)
1111
finally:
1112
bzrlib.ui.ui_factory = save_ui
1113
1114
1115
def show_version():
1116
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1117
# is bzrlib itself in a branch?
1118
bzrrev = bzrlib.get_bzr_revision()
1119
if bzrrev:
1120
print " (bzr checkout, revision %d {%s})" % bzrrev
1121
print bzrlib.__copyright__
1122
print "http://bazaar-ng.org/"
1123
print
1124
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1125
print "you may use, modify and redistribute it under the terms of the GNU"
1126
print "General Public License version 2 or later."
1127
1128
1129
class cmd_version(Command):
1130
"""Show version of bzr."""
1131
def run(self):
1132
show_version()
1133
1134
class cmd_rocks(Command):
1135
"""Statement of optimism."""
1136
hidden = True
1137
def run(self):
1138
print "it sure does!"
1139
1140
1141
class cmd_find_merge_base(Command):
1142
"""Find and print a base revision for merging two branches.
1143
1144
TODO: Options to specify revisions on either side, as if
1145
merging only part of the history.
1146
"""
1147
takes_args = ['branch', 'other']
1148
hidden = True
1149
1150
def run(self, branch, other):
1151
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1152
1153
branch1 = Branch.open_containing(branch)
1154
branch2 = Branch.open_containing(other)
1155
1156
history_1 = branch1.revision_history()
1157
history_2 = branch2.revision_history()
1158
1159
last1 = branch1.last_patch()
1160
last2 = branch2.last_patch()
1161
1162
source = MultipleRevisionSources(branch1, branch2)
1163
1164
base_rev_id = common_ancestor(last1, last2, source)
1165
1166
print 'merge base is revision %s' % base_rev_id
1167
1168
return
1169
1170
if base_revno is None:
1171
raise bzrlib.errors.UnrelatedBranches()
1172
1173
print ' r%-6d in %s' % (base_revno, branch)
1174
1175
other_revno = branch2.revision_id_to_revno(base_revid)
1176
1177
print ' r%-6d in %s' % (other_revno, other)
1178
1179
1180
1181
class cmd_merge(Command):
1182
"""Perform a three-way merge.
1183
1184
The branch is the branch you will merge from. By default, it will
1185
merge the latest revision. If you specify a revision, that
1186
revision will be merged. If you specify two revisions, the first
1187
will be used as a BASE, and the second one as OTHER. Revision
1188
numbers are always relative to the specified branch.
1189
1190
By default bzr will try to merge in all new work from the other
1191
branch, automatically determining an appropriate base. If this
1192
fails, you may need to give an explicit base.
1193
1194
Examples:
1195
1196
To merge the latest revision from bzr.dev
1197
bzr merge ../bzr.dev
1198
1199
To merge changes up to and including revision 82 from bzr.dev
1200
bzr merge -r 82 ../bzr.dev
1201
1202
To merge the changes introduced by 82, without previous changes:
1203
bzr merge -r 81..82 ../bzr.dev
1204
1205
merge refuses to run if there are any uncommitted changes, unless
1206
--force is given.
1207
"""
1208
takes_args = ['branch?']
1209
takes_options = ['revision', 'force', 'merge-type']
1210
1211
def run(self, branch='.', revision=None, force=False,
1212
merge_type=None):
1213
from bzrlib.merge import merge
1214
from bzrlib.merge_core import ApplyMerge3
1215
if merge_type is None:
1216
merge_type = ApplyMerge3
1217
1218
if revision is None or len(revision) < 1:
1219
base = [None, None]
1220
other = [branch, -1]
1221
else:
1222
if len(revision) == 1:
1223
base = [None, None]
1224
other = [branch, revision[0].in_history(branch).revno]
1225
else:
1226
assert len(revision) == 2
1227
if None in revision:
1228
raise BzrCommandError(
1229
"Merge doesn't permit that revision specifier.")
1230
from bzrlib.branch import Branch
1231
b = Branch.open(branch)
1232
1233
base = [branch, revision[0].in_history(b).revno]
1234
other = [branch, revision[1].in_history(b).revno]
1235
1236
try:
1237
merge(other, base, check_clean=(not force), merge_type=merge_type)
1238
except bzrlib.errors.AmbiguousBase, e:
1239
m = ("sorry, bzr can't determine the right merge base yet\n"
1240
"candidates are:\n "
1241
+ "\n ".join(e.bases)
1242
+ "\n"
1243
"please specify an explicit base with -r,\n"
1244
"and (if you want) report this to the bzr developers\n")
1245
log_error(m)
1246
1247
1248
class cmd_revert(Command):
1249
"""Reverse all changes since the last commit.
1250
1251
Only versioned files are affected. Specify filenames to revert only
1252
those files. By default, any files that are changed will be backed up
1253
first. Backup files have a '~' appended to their name.
1254
"""
1255
takes_options = ['revision', 'no-backup']
1256
takes_args = ['file*']
1257
aliases = ['merge-revert']
1258
1259
def run(self, revision=None, no_backup=False, file_list=None):
1260
from bzrlib.merge import merge
1261
from bzrlib.branch import Branch
1262
from bzrlib.commands import parse_spec
1263
1264
if file_list is not None:
1265
if len(file_list) == 0:
1266
raise BzrCommandError("No files specified")
1267
if revision is None:
1268
revno = -1
1269
elif len(revision) != 1:
1270
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1271
else:
1272
b = Branch.open_containing('.')
1273
revno = revision[0].in_history(b).revno
1274
merge(('.', revno), parse_spec('.'),
1275
check_clean=False,
1276
ignore_zero=True,
1277
backup_files=not no_backup,
1278
file_list=file_list)
1279
if not file_list:
1280
Branch.open_containing('.').set_pending_merges([])
1281
1282
1283
class cmd_assert_fail(Command):
1284
"""Test reporting of assertion failures"""
1285
hidden = True
1286
def run(self):
1287
assert False, "always fails"
1288
1289
1290
class cmd_help(Command):
1291
"""Show help on a command or other topic.
1292
1293
For a list of all available commands, say 'bzr help commands'."""
1294
takes_options = ['long']
1295
takes_args = ['topic?']
1296
aliases = ['?']
1297
1298
def run(self, topic=None, long=False):
1299
import help
1300
if topic is None and long:
1301
topic = "commands"
1302
help.help(topic)
1303
1304
1305
class cmd_shell_complete(Command):
1306
"""Show appropriate completions for context.
1307
1308
For a list of all available commands, say 'bzr shell-complete'."""
1309
takes_args = ['context?']
1310
aliases = ['s-c']
1311
hidden = True
1312
1313
def run(self, context=None):
1314
import shellcomplete
1315
shellcomplete.shellcomplete(context)
1316
1317
1318
class cmd_missing(Command):
1319
"""What is missing in this branch relative to other branch.
1320
"""
1321
takes_args = ['remote?']
1322
aliases = ['mis', 'miss']
1323
# We don't have to add quiet to the list, because
1324
# unknown options are parsed as booleans
1325
takes_options = ['verbose', 'quiet']
1326
1327
def run(self, remote=None, verbose=False, quiet=False):
1328
from bzrlib.errors import BzrCommandError
1329
from bzrlib.missing import show_missing
1330
1331
if verbose and quiet:
1332
raise BzrCommandError('Cannot pass both quiet and verbose')
1333
1334
b = Branch.open_containing('.')
1335
parent = b.get_parent()
1336
if remote is None:
1337
if parent is None:
1338
raise BzrCommandError("No missing location known or specified.")
1339
else:
1340
if not quiet:
1341
print "Using last location: %s" % parent
1342
remote = parent
1343
elif parent is None:
1344
# We only update parent if it did not exist, missing
1345
# should not change the parent
1346
b.set_parent(remote)
1347
br_remote = Branch.open_containing(remote)
1348
1349
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1350
1351
1352
1353
class cmd_plugins(Command):
1354
"""List plugins"""
1355
hidden = True
1356
def run(self):
1357
import bzrlib.plugin
1358
from inspect import getdoc
1359
for plugin in bzrlib.plugin.all_plugins:
1360
if hasattr(plugin, '__path__'):
1361
print plugin.__path__[0]
1362
elif hasattr(plugin, '__file__'):
1363
print plugin.__file__
1364
else:
1365
print `plugin`
1366
1367
d = getdoc(plugin)
1368
if d:
1369
print '\t', d.split('\n')[0]
1370
1371
Loggerhead is a web-based interface for Breezy
Version: 2.0.1