« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 408
- compare with another revision
- download diff
- download tarball
- view history from revision 408
- Committer: Martin Pool
- Date: 2005-05-09 04:38:31 UTC
- Revision ID: mbp@sourcefrog.net-20050509043831-d45f7832b7d4d5b0
- better message when refusing to add symlinks (from mpe)
- files added:
- bzrlib/cache.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- patches
- tools
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/store/__init__.py => bzrlib/store.py
- 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, 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_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.clone 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
revision_id = revision[0].in_history(br_from)[1]
411
else:
412
revision_id = 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, revision_id, 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_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
TODO: Allow diff across branches.
569
570
TODO: Option to use external diff command; could be GNU diff, wdiff,
571
or a graphical diff.
572
573
TODO: Python difflib is not exactly the same as unidiff; should
574
either fix it up or prefer to use an external diff.
575
576
TODO: If a directory is given, diff everything under that.
577
578
TODO: Selected-file diff is inefficient and doesn't show you
579
deleted files.
580
581
TODO: This probably handles non-Unix newlines poorly.
582
583
examples:
584
bzr diff
585
bzr diff -r1
586
bzr diff -r1..2
587
"""
588
589
takes_args = ['file*']
590
takes_options = ['revision', 'diff-options']
591
aliases = ['di', 'dif']
592
593
def run(self, revision=None, file_list=None, diff_options=None):
594
from bzrlib.diff import show_diff
595
596
if file_list:
597
b = Branch.open_containing(file_list[0])
598
file_list = [b.relpath(f) for f in file_list]
599
if file_list == ['']:
600
# just pointing to top-of-tree
601
file_list = None
602
else:
603
b = Branch.open_containing('.')
604
605
if revision is not None:
606
if len(revision) == 1:
607
show_diff(b, revision[0], specific_files=file_list,
608
external_diff_options=diff_options)
609
elif len(revision) == 2:
610
show_diff(b, revision[0], specific_files=file_list,
611
external_diff_options=diff_options,
612
revision2=revision[1])
613
else:
614
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
615
else:
616
show_diff(b, None, specific_files=file_list,
617
external_diff_options=diff_options)
618
619
620
621
622
class cmd_deleted(Command):
623
"""List files deleted in the working tree.
624
625
TODO: Show files deleted since a previous revision, or between two revisions.
626
"""
627
def run(self, show_ids=False):
628
b = Branch.open_containing('.')
629
old = b.basis_tree()
630
new = b.working_tree()
631
632
## TODO: Much more efficient way to do this: read in new
633
## directories with readdir, rather than stating each one. Same
634
## level of effort but possibly much less IO. (Or possibly not,
635
## if the directories are very large...)
636
637
for path, ie in old.inventory.iter_entries():
638
if not new.has_id(ie.file_id):
639
if show_ids:
640
print '%-50s %s' % (path, ie.file_id)
641
else:
642
print path
643
644
645
class cmd_modified(Command):
646
"""List files modified in working tree."""
647
hidden = True
648
def run(self):
649
from bzrlib.delta import compare_trees
650
651
b = Branch.open_containing('.')
652
td = compare_trees(b.basis_tree(), b.working_tree())
653
654
for path, id, kind, text_modified, meta_modified in td.modified:
655
print path
656
657
658
659
class cmd_added(Command):
660
"""List files added in working tree."""
661
hidden = True
662
def run(self):
663
b = Branch.open_containing('.')
664
wt = b.working_tree()
665
basis_inv = b.basis_tree().inventory
666
inv = wt.inventory
667
for file_id in inv:
668
if file_id in basis_inv:
669
continue
670
path = inv.id2path(file_id)
671
if not os.access(b.abspath(path), os.F_OK):
672
continue
673
print path
674
675
676
677
class cmd_root(Command):
678
"""Show the tree root directory.
679
680
The root is the nearest enclosing directory with a .bzr control
681
directory."""
682
takes_args = ['filename?']
683
def run(self, filename=None):
684
"""Print the branch root."""
685
b = Branch.open_containing(filename)
686
print b.base
687
688
689
class cmd_log(Command):
690
"""Show log of this branch.
691
692
To request a range of logs, you can use the command -r begin:end
693
-r revision requests a specific revision, -r :end or -r begin: are
694
also valid.
695
696
--message allows you to give a regular expression, which will be evaluated
697
so that only matching entries will be displayed.
698
699
TODO: Make --revision support uuid: and hash: [future tag:] notation.
700
701
"""
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
800
for fp, fc, kind, fid in tree.list_files():
801
if verbose:
802
if kind == 'directory':
803
kindch = '/'
804
elif kind == 'file':
805
kindch = ''
806
else:
807
kindch = '???'
808
809
print '%-8s %s%s' % (fc, fp, kindch)
810
else:
811
print fp
812
813
814
815
class cmd_unknowns(Command):
816
"""List unknown files."""
817
def run(self):
818
from bzrlib.osutils import quotefn
819
for f in Branch.open_containing('.').unknowns():
820
print quotefn(f)
821
822
823
824
class cmd_ignore(Command):
825
"""Ignore a command or pattern.
826
827
To remove patterns from the ignore list, edit the .bzrignore file.
828
829
If the pattern contains a slash, it is compared to the whole path
830
from the branch root. Otherwise, it is comapred to only the last
831
component of the path.
832
833
Ignore patterns are case-insensitive on case-insensitive systems.
834
835
Note: wildcards must be quoted from the shell on Unix.
836
837
examples:
838
bzr ignore ./Makefile
839
bzr ignore '*.class'
840
"""
841
takes_args = ['name_pattern']
842
843
def run(self, name_pattern):
844
from bzrlib.atomicfile import AtomicFile
845
import os.path
846
847
b = Branch.open_containing('.')
848
ifn = b.abspath('.bzrignore')
849
850
if os.path.exists(ifn):
851
f = open(ifn, 'rt')
852
try:
853
igns = f.read().decode('utf-8')
854
finally:
855
f.close()
856
else:
857
igns = ''
858
859
# TODO: If the file already uses crlf-style termination, maybe
860
# we should use that for the newly added lines?
861
862
if igns and igns[-1] != '\n':
863
igns += '\n'
864
igns += name_pattern + '\n'
865
866
try:
867
f = AtomicFile(ifn, 'wt')
868
f.write(igns.encode('utf-8'))
869
f.commit()
870
finally:
871
f.close()
872
873
inv = b.working_tree().inventory
874
if inv.path2id('.bzrignore'):
875
mutter('.bzrignore is already versioned')
876
else:
877
mutter('need to make new .bzrignore file versioned')
878
b.add(['.bzrignore'])
879
880
881
882
class cmd_ignored(Command):
883
"""List ignored files and the patterns that matched them.
884
885
See also: bzr ignore"""
886
def run(self):
887
tree = Branch.open_containing('.').working_tree()
888
for path, file_class, kind, file_id in tree.list_files():
889
if file_class != 'I':
890
continue
891
## XXX: Slightly inefficient since this was already calculated
892
pat = tree.is_ignored(path)
893
print '%-50s %s' % (path, pat)
894
895
896
class cmd_lookup_revision(Command):
897
"""Lookup the revision-id from a revision-number
898
899
example:
900
bzr lookup-revision 33
901
"""
902
hidden = True
903
takes_args = ['revno']
904
905
def run(self, revno):
906
try:
907
revno = int(revno)
908
except ValueError:
909
raise BzrCommandError("not a valid revision-number: %r" % revno)
910
911
print Branch.open_containing('.').get_rev_id(revno)
912
913
914
class cmd_export(Command):
915
"""Export past revision to destination directory.
916
917
If no revision is specified this exports the last committed revision.
918
919
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
920
given, try to find the format with the extension. If no extension
921
is found exports to a directory (equivalent to --format=dir).
922
923
Root may be the top directory for tar, tgz and tbz2 formats. If none
924
is given, the top directory will be the root name of the file."""
925
# TODO: list known exporters
926
takes_args = ['dest']
927
takes_options = ['revision', 'format', 'root']
928
def run(self, dest, revision=None, format=None, root=None):
929
import os.path
930
b = Branch.open_containing('.')
931
if revision is None:
932
rev_id = b.last_revision()
933
else:
934
if len(revision) != 1:
935
raise BzrError('bzr export --revision takes exactly 1 argument')
936
rev_id = revision[0].in_history(b).rev_id
937
t = b.revision_tree(rev_id)
938
arg_root, ext = os.path.splitext(os.path.basename(dest))
939
if ext in ('.gz', '.bz2'):
940
new_root, new_ext = os.path.splitext(arg_root)
941
if new_ext == '.tar':
942
arg_root = new_root
943
ext = new_ext + ext
944
if root is None:
945
root = arg_root
946
if not format:
947
if ext in (".tar",):
948
format = "tar"
949
elif ext in (".tar.gz", ".tgz"):
950
format = "tgz"
951
elif ext in (".tar.bz2", ".tbz2"):
952
format = "tbz2"
953
else:
954
format = "dir"
955
t.export(dest, format, root)
956
957
958
class cmd_cat(Command):
959
"""Write a file's text from a previous revision."""
960
961
takes_options = ['revision']
962
takes_args = ['filename']
963
964
def run(self, filename, revision=None):
965
if revision is None:
966
raise BzrCommandError("bzr cat requires a revision number")
967
elif len(revision) != 1:
968
raise BzrCommandError("bzr cat --revision takes exactly one number")
969
b = Branch.open_containing('.')
970
b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
971
972
973
class cmd_local_time_offset(Command):
974
"""Show the offset in seconds from GMT to local time."""
975
hidden = True
976
def run(self):
977
print bzrlib.osutils.local_time_offset()
978
979
980
981
class cmd_commit(Command):
982
"""Commit changes into a new revision.
983
984
If no arguments are given, the entire tree is committed.
985
986
If selected files are specified, only changes to those files are
987
committed. If a directory is specified then the directory and everything
988
within it is committed.
989
990
A selected-file commit may fail in some cases where the committed
991
tree would be invalid, such as trying to commit a file in a
992
newly-added directory that is not itself committed.
993
994
TODO: Run hooks on tree to-be-committed, and after commit.
995
996
TODO: Strict commit that fails if there are unknown or deleted files.
997
"""
998
takes_args = ['selected*']
999
takes_options = ['message', 'file', 'verbose', 'unchanged']
1000
aliases = ['ci', 'checkin']
1001
1002
# TODO: Give better message for -s, --summary, used by tla people
1003
1004
# XXX: verbose currently does nothing
1005
1006
def run(self, message=None, file=None, verbose=True, selected_list=None,
1007
unchanged=False):
1008
from bzrlib.errors import PointlessCommit
1009
from bzrlib.msgeditor import edit_commit_message
1010
from bzrlib.status import show_status
1011
from cStringIO import StringIO
1012
1013
b = Branch.open_containing('.')
1014
if selected_list:
1015
selected_list = [b.relpath(s) for s in selected_list]
1016
1017
if not message and not file:
1018
catcher = StringIO()
1019
show_status(b, specific_files=selected_list,
1020
to_file=catcher)
1021
message = edit_commit_message(catcher.getvalue())
1022
1023
if message is None:
1024
raise BzrCommandError("please specify a commit message"
1025
" with either --message or --file")
1026
elif message and file:
1027
raise BzrCommandError("please specify either --message or --file")
1028
1029
if file:
1030
import codecs
1031
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1032
1033
try:
1034
b.commit(message,
1035
specific_files=selected_list,
1036
allow_pointless=unchanged)
1037
except PointlessCommit:
1038
# FIXME: This should really happen before the file is read in;
1039
# perhaps prepare the commit; get the message; then actually commit
1040
raise BzrCommandError("no changes to commit",
1041
["use --unchanged to commit anyhow"])
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
hidden = True
1113
takes_options = ['verbose', 'pattern']
1114
def run(self, verbose=False, pattern=".*"):
1115
import bzrlib.ui
1116
from bzrlib.selftest import selftest
1117
# we don't want progress meters from the tests to go to the
1118
# real output; and we don't want log messages cluttering up
1119
# the real logs.
1120
save_ui = bzrlib.ui.ui_factory
1121
bzrlib.trace.info('running tests...')
1122
try:
1123
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1124
result = selftest(verbose=verbose, pattern=pattern)
1125
if result:
1126
bzrlib.trace.info('tests passed')
1127
else:
1128
bzrlib.trace.info('tests failed')
1129
return int(not result)
1130
finally:
1131
bzrlib.ui.ui_factory = save_ui
1132
1133
1134
def show_version():
1135
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1136
# is bzrlib itself in a branch?
1137
bzrrev = bzrlib.get_bzr_revision()
1138
if bzrrev:
1139
print " (bzr checkout, revision %d {%s})" % bzrrev
1140
print bzrlib.__copyright__
1141
print "http://bazaar-ng.org/"
1142
print
1143
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1144
print "you may use, modify and redistribute it under the terms of the GNU"
1145
print "General Public License version 2 or later."
1146
1147
1148
class cmd_version(Command):
1149
"""Show version of bzr."""
1150
def run(self):
1151
show_version()
1152
1153
class cmd_rocks(Command):
1154
"""Statement of optimism."""
1155
hidden = True
1156
def run(self):
1157
print "it sure does!"
1158
1159
1160
class cmd_find_merge_base(Command):
1161
"""Find and print a base revision for merging two branches.
1162
1163
TODO: Options to specify revisions on either side, as if
1164
merging only part of the history.
1165
"""
1166
takes_args = ['branch', 'other']
1167
hidden = True
1168
1169
def run(self, branch, other):
1170
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1171
1172
branch1 = Branch.open_containing(branch)
1173
branch2 = Branch.open_containing(other)
1174
1175
history_1 = branch1.revision_history()
1176
history_2 = branch2.revision_history()
1177
1178
last1 = branch1.last_revision()
1179
last2 = branch2.last_revision()
1180
1181
source = MultipleRevisionSources(branch1, branch2)
1182
1183
base_rev_id = common_ancestor(last1, last2, source)
1184
1185
print 'merge base is revision %s' % base_rev_id
1186
1187
return
1188
1189
if base_revno is None:
1190
raise bzrlib.errors.UnrelatedBranches()
1191
1192
print ' r%-6d in %s' % (base_revno, branch)
1193
1194
other_revno = branch2.revision_id_to_revno(base_revid)
1195
1196
print ' r%-6d in %s' % (other_revno, other)
1197
1198
1199
1200
class cmd_merge(Command):
1201
"""Perform a three-way merge.
1202
1203
The branch is the branch you will merge from. By default, it will
1204
merge the latest revision. If you specify a revision, that
1205
revision will be merged. If you specify two revisions, the first
1206
will be used as a BASE, and the second one as OTHER. Revision
1207
numbers are always relative to the specified branch.
1208
1209
By default bzr will try to merge in all new work from the other
1210
branch, automatically determining an appropriate base. If this
1211
fails, you may need to give an explicit base.
1212
1213
Examples:
1214
1215
To merge the latest revision from bzr.dev
1216
bzr merge ../bzr.dev
1217
1218
To merge changes up to and including revision 82 from bzr.dev
1219
bzr merge -r 82 ../bzr.dev
1220
1221
To merge the changes introduced by 82, without previous changes:
1222
bzr merge -r 81..82 ../bzr.dev
1223
1224
merge refuses to run if there are any uncommitted changes, unless
1225
--force is given.
1226
"""
1227
takes_args = ['branch?']
1228
takes_options = ['revision', 'force', 'merge-type']
1229
1230
def run(self, branch='.', revision=None, force=False,
1231
merge_type=None):
1232
from bzrlib.merge import merge
1233
from bzrlib.merge_core import ApplyMerge3
1234
if merge_type is None:
1235
merge_type = ApplyMerge3
1236
1237
if revision is None or len(revision) < 1:
1238
base = [None, None]
1239
other = [branch, -1]
1240
else:
1241
if len(revision) == 1:
1242
base = [None, None]
1243
other = [branch, revision[0].in_history(branch).revno]
1244
else:
1245
assert len(revision) == 2
1246
if None in revision:
1247
raise BzrCommandError(
1248
"Merge doesn't permit that revision specifier.")
1249
b = Branch.open(branch)
1250
1251
base = [branch, revision[0].in_history(b).revno]
1252
other = [branch, revision[1].in_history(b).revno]
1253
1254
try:
1255
merge(other, base, check_clean=(not force), merge_type=merge_type)
1256
except bzrlib.errors.AmbiguousBase, e:
1257
m = ("sorry, bzr can't determine the right merge base yet\n"
1258
"candidates are:\n "
1259
+ "\n ".join(e.bases)
1260
+ "\n"
1261
"please specify an explicit base with -r,\n"
1262
"and (if you want) report this to the bzr developers\n")
1263
log_error(m)
1264
1265
1266
class cmd_revert(Command):
1267
"""Reverse all changes since the last commit.
1268
1269
Only versioned files are affected. Specify filenames to revert only
1270
those files. By default, any files that are changed will be backed up
1271
first. Backup files have a '~' appended to their name.
1272
"""
1273
takes_options = ['revision', 'no-backup']
1274
takes_args = ['file*']
1275
aliases = ['merge-revert']
1276
1277
def run(self, revision=None, no_backup=False, file_list=None):
1278
from bzrlib.merge import merge
1279
from bzrlib.commands import parse_spec
1280
1281
if file_list is not None:
1282
if len(file_list) == 0:
1283
raise BzrCommandError("No files specified")
1284
if revision is None:
1285
revno = -1
1286
elif len(revision) != 1:
1287
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1288
else:
1289
b = Branch.open_containing('.')
1290
revno = revision[0].in_history(b).revno
1291
merge(('.', revno), parse_spec('.'),
1292
check_clean=False,
1293
ignore_zero=True,
1294
backup_files=not no_backup,
1295
file_list=file_list)
1296
if not file_list:
1297
Branch.open_containing('.').set_pending_merges([])
1298
1299
1300
class cmd_assert_fail(Command):
1301
"""Test reporting of assertion failures"""
1302
hidden = True
1303
def run(self):
1304
assert False, "always fails"
1305
1306
1307
class cmd_help(Command):
1308
"""Show help on a command or other topic.
1309
1310
For a list of all available commands, say 'bzr help commands'."""
1311
takes_options = ['long']
1312
takes_args = ['topic?']
1313
aliases = ['?']
1314
1315
def run(self, topic=None, long=False):
1316
import help
1317
if topic is None and long:
1318
topic = "commands"
1319
help.help(topic)
1320
1321
1322
class cmd_shell_complete(Command):
1323
"""Show appropriate completions for context.
1324
1325
For a list of all available commands, say 'bzr shell-complete'."""
1326
takes_args = ['context?']
1327
aliases = ['s-c']
1328
hidden = True
1329
1330
def run(self, context=None):
1331
import shellcomplete
1332
shellcomplete.shellcomplete(context)
1333
1334
1335
class cmd_fetch(Command):
1336
"""Copy in history from another branch but don't merge it.
1337
1338
This is an internal method used for pull and merge."""
1339
hidden = True
1340
takes_args = ['from_branch', 'to_branch']
1341
def run(self, from_branch, to_branch):
1342
from bzrlib.fetch import Fetcher
1343
from bzrlib.branch import Branch
1344
from_b = Branch(from_branch)
1345
to_b = Branch(to_branch)
1346
Fetcher(to_b, from_b)
1347
1348
1349
1350
class cmd_missing(Command):
1351
"""What is missing in this branch relative to other branch.
1352
"""
1353
# TODO: rewrite this in terms of ancestry so that it shows only
1354
# unmerged things
1355
1356
takes_args = ['remote?']
1357
aliases = ['mis', 'miss']
1358
# We don't have to add quiet to the list, because
1359
# unknown options are parsed as booleans
1360
takes_options = ['verbose', 'quiet']
1361
1362
def run(self, remote=None, verbose=False, quiet=False):
1363
from bzrlib.errors import BzrCommandError
1364
from bzrlib.missing import show_missing
1365
1366
if verbose and quiet:
1367
raise BzrCommandError('Cannot pass both quiet and verbose')
1368
1369
b = Branch.open_containing('.')
1370
parent = b.get_parent()
1371
if remote is None:
1372
if parent is None:
1373
raise BzrCommandError("No missing location known or specified.")
1374
else:
1375
if not quiet:
1376
print "Using last location: %s" % parent
1377
remote = parent
1378
elif parent is None:
1379
# We only update parent if it did not exist, missing
1380
# should not change the parent
1381
b.set_parent(remote)
1382
br_remote = Branch.open_containing(remote)
1383
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1384
1385
1386
class cmd_plugins(Command):
1387
"""List plugins"""
1388
hidden = True
1389
def run(self):
1390
import bzrlib.plugin
1391
from inspect import getdoc
1392
for plugin in bzrlib.plugin.all_plugins:
1393
if hasattr(plugin, '__path__'):
1394
print plugin.__path__[0]
1395
elif hasattr(plugin, '__file__'):
1396
print plugin.__file__
1397
else:
1398
print `plugin`
1399
1400
d = getdoc(plugin)
1401
if d:
1402
print '\t', d.split('\n')[0]
1403
1404
Loggerhead is a web-based interface for Breezy
Version: 2.0.1