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