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