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