« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 24
- compare with another revision
- download diff
- download tarball
- view history from revision 24
- Committer: mbp at sourcefrog
- Date: 2005-03-11 23:23:53 UTC
- Revision ID: mbp@sourcefrog.net-20050311232353-f5e33da490872c6a
Add .bzrignore file
- files added:
- doc/roadmap.txt
- files removed:
- .rsyncexclude
- contrib
- contrib/bash
- contrib/zsh
- elementtree
- urlgrabber
- files renamed:
- bzrlib/commands.py => bzr.py
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005 Canonical Ltd
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
2
3
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
26
27
from trace import mutter, note
27
28
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
28
29
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
30
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
30
31
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
32
joinpath, sha_string, file_kind, local_time_offset
32
33
from store import ImmutableStore
33
34
from revision import Revision
34
from errors import bailout, BzrError
35
from errors import bailout
35
36
from textui import show_status
36
37
from diff import diff_trees
37
38
40
41
41
42
42
43
43
def find_branch_root(f=None):
44
"""Find the branch root enclosing f, or pwd.
45
46
It is not necessary that f exists.
47
48
Basically we keep looking up until we find the control directory or
49
run into the root."""
50
if f == None:
51
f = os.getcwd()
52
elif hasattr(os.path, 'realpath'):
53
f = os.path.realpath(f)
54
else:
55
f = os.path.abspath(f)
56
57
orig_f = f
58
59
while True:
60
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
61
return f
62
head, tail = os.path.split(f)
63
if head == f:
64
# reached the root, whatever that may be
65
raise BzrError('%r is not in a branch' % orig_f)
66
f = head
67
68
44
69
45
70
46
######################################################################
73
49
class Branch:
74
50
"""Branch holding a history of revisions.
75
51
76
TODO: Perhaps use different stores for different classes of object,
52
:todo: Perhaps use different stores for different classes of object,
77
53
so that we can keep track of how much space each one uses,
78
54
or garbage-collect them.
79
55
80
TODO: Add a RemoteBranch subclass. For the basic case of read-only
56
:todo: Add a RemoteBranch subclass. For the basic case of read-only
81
57
HTTP access this should be very easy by,
82
58
just redirecting controlfile access into HTTP requests.
83
59
We would need a RemoteStore working similarly.
84
60
85
TODO: Keep the on-disk branch locked while the object exists.
61
:todo: Keep the on-disk branch locked while the object exists.
86
62
87
TODO: mkdir() method.
63
:todo: mkdir() method.
88
64
"""
89
def __init__(self, base, init=False, find_root=True):
65
def __init__(self, base, init=False):
90
66
"""Create new branch object at a particular location.
91
67
92
base -- Base directory for the branch.
93
94
init -- If True, create new control files in a previously
68
:param base: Base directory for the branch.
69
70
:param init: If True, create new control files in a previously
95
71
unversioned directory. If False, the branch must already
96
72
be versioned.
97
73
98
find_root -- If true and init is false, find the root of the
99
existing branch containing base.
100
101
74
In the test suite, creation of new trees is tested using the
102
75
`ScratchBranch` class.
103
76
"""
77
self.base = os.path.realpath(base)
104
78
if init:
105
self.base = os.path.realpath(base)
106
79
self._make_control()
107
elif find_root:
108
self.base = find_branch_root(base)
109
80
else:
110
self.base = os.path.realpath(base)
111
81
if not isdir(self.controlfilename('.')):
112
82
bailout("not a bzr branch: %s" % quotefn(base),
113
83
['use "bzr init" to initialize a new working tree',
114
84
'current bzr can only operate from top-of-tree'])
115
self._check_format()
85
self._check_format()
116
86
117
87
self.text_store = ImmutableStore(self.controlfilename('text-store'))
118
88
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
126
96
__repr__ = __str__
127
97
128
98
129
def abspath(self, name):
130
"""Return absolute filename for something in the branch"""
99
def _rel(self, name):
100
"""Return filename relative to branch top"""
131
101
return os.path.join(self.base, name)
132
133
134
def relpath(self, path):
135
"""Return path relative to this branch of something inside it.
136
137
Raises an error if path is not in this branch."""
138
rp = os.path.realpath(path)
139
# FIXME: windows
140
if not rp.startswith(self.base):
141
bailout("path %r is not within branch %r" % (rp, self.base))
142
rp = rp[len(self.base):]
143
rp = rp.lstrip(os.sep)
144
return rp
145
102
146
103
147
104
def controlfilename(self, file_or_path):
148
105
"""Return location relative to branch."""
152
109
153
110
154
111
def controlfile(self, file_or_path, mode='r'):
155
"""Open a control file for this branch.
156
157
There are two classes of file in the control directory: text
158
and binary. binary files are untranslated byte streams. Text
159
control files are stored with Unix newlines and in UTF-8, even
160
if the platform or locale defaults are different.
161
"""
162
163
fn = self.controlfilename(file_or_path)
164
165
if mode == 'rb' or mode == 'wb':
166
return file(fn, mode)
167
elif mode == 'r' or mode == 'w':
168
# open in binary mode anyhow so there's no newline translation;
169
# codecs uses line buffering by default; don't want that.
170
import codecs
171
return codecs.open(fn, mode + 'b', 'utf-8',
172
buffering=60000)
173
else:
174
raise BzrError("invalid controlfile mode %r" % mode)
175
112
"""Open a control file for this branch"""
113
return file(self.controlfilename(file_or_path), mode)
176
114
177
115
178
116
def _make_control(self):
197
135
198
136
In the future, we might need different in-memory Branch
199
137
classes to support downlevel branches. But not yet.
200
"""
201
# This ignores newlines so that we can open branches created
202
# on Windows from Linux and so on. I think it might be better
203
# to always make all internal files in unix format.
204
fmt = self.controlfile('branch-format', 'r').read()
205
fmt.replace('\r\n', '')
138
"""
139
# read in binary mode to detect newline wierdness.
140
fmt = self.controlfile('branch-format', 'rb').read()
206
141
if fmt != BZR_BRANCH_FORMAT:
207
142
bailout('sorry, branch format %r not supported' % fmt,
208
143
['use a different bzr version',
212
147
def read_working_inventory(self):
213
148
"""Read the working inventory."""
214
149
before = time.time()
215
# ElementTree does its own conversion from UTF-8, so open in
216
# binary.
217
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
150
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
218
151
mutter("loaded inventory of %d items in %f"
219
152
% (len(inv), time.time() - before))
220
153
return inv
227
160
will be committed to the next revision.
228
161
"""
229
162
## TODO: factor out to atomicfile? is rename safe on windows?
230
## TODO: Maybe some kind of clean/dirty marker on inventory?
231
163
tmpfname = self.controlfilename('inventory.tmp')
232
tmpf = file(tmpfname, 'wb')
164
tmpf = file(tmpfname, 'w')
233
165
inv.write_xml(tmpf)
234
166
tmpf.close()
235
inv_fname = self.controlfilename('inventory')
236
if sys.platform == 'win32':
237
os.remove(inv_fname)
238
os.rename(tmpfname, inv_fname)
167
os.rename(tmpfname, self.controlfilename('inventory'))
239
168
mutter('wrote working inventory')
240
169
241
170
246
175
def add(self, files, verbose=False):
247
176
"""Make files versioned.
248
177
249
Note that the command line normally calls smart_add instead.
250
251
178
This puts the files in the Added state, so that they will be
252
179
recorded by the next commit.
253
180
254
TODO: Perhaps have an option to add the ids even if the files do
181
:todo: Perhaps have an option to add the ids even if the files do
255
182
not (yet) exist.
256
183
257
TODO: Perhaps return the ids of the files? But then again it
184
:todo: Perhaps return the ids of the files? But then again it
258
185
is easy to retrieve them if they're needed.
259
186
260
TODO: Option to specify file id.
187
:todo: Option to specify file id.
261
188
262
TODO: Adding a directory should optionally recurse down and
189
:todo: Adding a directory should optionally recurse down and
263
190
add all non-ignored children. Perhaps do that in a
264
191
higher-level method.
265
192
301
228
if len(fp) == 0:
302
229
bailout("cannot add top-level %r" % f)
303
230
304
fullpath = os.path.normpath(self.abspath(f))
305
306
try:
307
kind = file_kind(fullpath)
308
except OSError:
309
# maybe something better?
310
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
311
312
if kind != 'file' and kind != 'directory':
313
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
314
315
file_id = gen_file_id(f)
316
inv.add_path(f, kind=kind, file_id=file_id)
317
231
fullpath = os.path.normpath(self._rel(f))
232
233
if isfile(fullpath):
234
kind = 'file'
235
elif isdir(fullpath):
236
kind = 'directory'
237
else:
238
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
239
240
if len(fp) > 1:
241
parent_name = joinpath(fp[:-1])
242
mutter("lookup parent %r" % parent_name)
243
parent_id = inv.path2id(parent_name)
244
if parent_id == None:
245
bailout("cannot add: parent %r is not versioned"
246
% joinpath(fp[:-1]))
247
else:
248
parent_id = None
249
250
file_id = _gen_file_id(fp[-1])
251
inv.add(InventoryEntry(file_id, fp[-1], kind=kind, parent_id=parent_id))
318
252
if verbose:
319
253
show_status('A', kind, quotefn(f))
320
254
321
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
322
255
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
256
% (f, file_id, kind, parent_id))
323
257
self._write_inventory(inv)
324
258
325
259
326
def print_file(self, file, revno):
327
"""Print `file` to stdout."""
328
tree = self.revision_tree(self.lookup_revision(revno))
329
# use inventory as it was in that revision
330
file_id = tree.inventory.path2id(file)
331
if not file_id:
332
bailout("%r is not present in revision %d" % (file, revno))
333
tree.print_file(file_id)
334
335
260
336
261
def remove(self, files, verbose=False):
337
262
"""Mark nominated files for removal from the inventory.
338
263
339
264
This does not remove their text. This does not run on
340
265
341
TODO: Refuse to remove modified files unless --force is given?
266
:todo: Refuse to remove modified files unless --force is given?
342
267
343
268
>>> b = ScratchBranch(files=['foo'])
344
269
>>> b.add('foo')
362
287
>>> b.working_tree().has_filename('foo')
363
288
True
364
289
365
TODO: Do something useful with directories.
290
:todo: Do something useful with directories.
366
291
367
TODO: Should this remove the text or not? Tough call; not
292
:todo: Should this remove the text or not? Tough call; not
368
293
removing may be useful and the user can just use use rm, and
369
294
is the opposite of add. Removing it is consistent with most
370
295
other tools. Maybe an option.
375
300
if isinstance(files, types.StringTypes):
376
301
files = [files]
377
302
378
tree = self.working_tree()
379
inv = tree.inventory
303
inv = self.read_working_inventory()
380
304
381
305
# do this before any modifications
382
306
for f in files:
385
309
bailout("cannot remove unversioned file %s" % quotefn(f))
386
310
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
387
311
if verbose:
388
# having remove it, it must be either ignored or unknown
389
if tree.is_ignored(f):
390
new_status = 'I'
391
else:
392
new_status = '?'
393
show_status(new_status, inv[fid].kind, quotefn(f))
312
show_status('D', inv[fid].kind, quotefn(f))
394
313
del inv[fid]
395
314
396
315
self._write_inventory(inv)
434
353
be robust against files disappearing, moving, etc. So the
435
354
whole thing is a bit hard.
436
355
437
timestamp -- if not None, seconds-since-epoch for a
356
:param timestamp: if not None, seconds-since-epoch for a
438
357
postdated/predated commit.
439
358
"""
440
359
463
382
464
383
entry = entry.copy()
465
384
466
p = self.abspath(path)
385
p = self._rel(path)
467
386
file_id = entry.file_id
468
387
mutter('commit prep file %s, id %r ' % (p, file_id))
469
388
509
428
entry.text_id)
510
429
511
430
else:
512
entry.text_id = gen_file_id(entry.name)
431
entry.text_id = _gen_file_id(entry.name)
513
432
self.text_store.add(content, entry.text_id)
514
433
mutter(' stored with text_id {%s}' % entry.text_id)
515
434
if verbose:
517
436
state = 'A'
518
437
elif (old_ie.name == entry.name
519
438
and old_ie.parent_id == entry.parent_id):
439
state = 'R'
440
else:
520
441
state = 'M'
521
else:
522
state = 'R'
523
442
524
443
show_status(state, entry.kind, quotefn(path))
525
444
578
497
## TODO: Also calculate and store the inventory SHA1
579
498
mutter("committing patch r%d" % (self.revno() + 1))
580
499
581
582
self.append_revision(rev_id)
583
584
if verbose:
585
note("commited r%d" % self.revno())
586
587
588
def append_revision(self, revision_id):
589
mutter("add {%s} to revision-history" % revision_id)
590
rev_history = self.revision_history()
591
592
tmprhname = self.controlfilename('revision-history.tmp')
593
rhname = self.controlfilename('revision-history')
594
595
f = file(tmprhname, 'wt')
596
rev_history.append(revision_id)
597
f.write('\n'.join(rev_history))
598
f.write('\n')
599
f.close()
600
601
if sys.platform == 'win32':
602
os.remove(rhname)
603
os.rename(tmprhname, rhname)
604
500
mutter("append to revision-history")
501
self.controlfile('revision-history', 'at').write(rev_id + '\n')
502
503
mutter("done!")
605
504
606
505
607
506
def get_revision(self, revision_id):
614
513
def get_inventory(self, inventory_id):
615
514
"""Get Inventory object by hash.
616
515
617
TODO: Perhaps for this and similar methods, take a revision
516
:todo: Perhaps for this and similar methods, take a revision
618
517
parameter which can be either an integer revno or a
619
518
string hash."""
620
519
i = Inventory.read_xml(self.inventory_store[inventory_id])
635
534
>>> ScratchBranch().revision_history()
636
535
[]
637
536
"""
638
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
537
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
639
538
640
539
641
540
def revno(self):
663
562
ph = self.revision_history()
664
563
if ph:
665
564
return ph[-1]
666
else:
667
return None
668
565
669
566
670
567
def lookup_revision(self, revno):
671
568
"""Return revision hash for revision number."""
676
573
# list is 0-based; revisions are 1-based
677
574
return self.revision_history()[revno-1]
678
575
except IndexError:
679
raise BzrError("no such revision %s" % revno)
576
bailout("no such revision %s" % revno)
680
577
681
578
682
579
def revision_tree(self, revision_id):
720
617
721
618
722
619
723
def write_log(self, show_timezone='original', verbose=False):
620
def write_log(self, show_timezone='original'):
724
621
"""Write out human-readable log of commits to this branch
725
622
726
utc -- If true, show dates in universal time, not local time."""
623
:param utc: If true, show dates in universal time, not local time."""
727
624
## TODO: Option to choose either original, utc or local timezone
728
625
revno = 1
729
626
precursor = None
748
645
for l in rev.message.split('\n'):
749
646
print ' ' + l
750
647
751
if verbose == True and precursor != None:
752
print 'changed files:'
753
tree = self.revision_tree(p)
754
prevtree = self.revision_tree(precursor)
755
756
for file_state, fid, old_name, new_name, kind in \
757
diff_trees(prevtree, tree, ):
758
if file_state == 'A' or file_state == 'M':
759
show_status(file_state, kind, new_name)
760
elif file_state == 'D':
761
show_status(file_state, kind, old_name)
762
elif file_state == 'R':
763
show_status(file_state, kind,
764
old_name + ' => ' + new_name)
765
766
648
revno += 1
767
649
precursor = p
768
650
769
651
770
def rename_one(self, from_rel, to_rel):
771
"""Rename one file.
772
773
This can change the directory or the filename or both.
774
"""
775
tree = self.working_tree()
776
inv = tree.inventory
777
if not tree.has_filename(from_rel):
778
bailout("can't rename: old working file %r does not exist" % from_rel)
779
if tree.has_filename(to_rel):
780
bailout("can't rename: new working file %r already exists" % to_rel)
781
782
file_id = inv.path2id(from_rel)
783
if file_id == None:
784
bailout("can't rename: old name %r is not versioned" % from_rel)
785
786
if inv.path2id(to_rel):
787
bailout("can't rename: new name %r is already versioned" % to_rel)
788
789
to_dir, to_tail = os.path.split(to_rel)
790
to_dir_id = inv.path2id(to_dir)
791
if to_dir_id == None and to_dir != '':
792
bailout("can't determine destination directory id for %r" % to_dir)
793
794
mutter("rename_one:")
795
mutter(" file_id {%s}" % file_id)
796
mutter(" from_rel %r" % from_rel)
797
mutter(" to_rel %r" % to_rel)
798
mutter(" to_dir %r" % to_dir)
799
mutter(" to_dir_id {%s}" % to_dir_id)
800
801
inv.rename(file_id, to_dir_id, to_tail)
802
803
print "%s => %s" % (from_rel, to_rel)
804
805
from_abs = self.abspath(from_rel)
806
to_abs = self.abspath(to_rel)
807
try:
808
os.rename(from_abs, to_abs)
809
except OSError, e:
810
bailout("failed to rename %r to %r: %s"
811
% (from_abs, to_abs, e[1]),
812
["rename rolled back"])
813
814
self._write_inventory(inv)
815
816
817
818
def move(self, from_paths, to_name):
819
"""Rename files.
820
821
to_name must exist as a versioned directory.
822
823
If to_name exists and is a directory, the files are moved into
824
it, keeping their old names. If it is a directory,
825
826
Note that to_name is only the last component of the new name;
827
this doesn't change the directory.
828
"""
829
## TODO: Option to move IDs only
830
assert not isinstance(from_paths, basestring)
831
tree = self.working_tree()
832
inv = tree.inventory
833
to_abs = self.abspath(to_name)
834
if not isdir(to_abs):
835
bailout("destination %r is not a directory" % to_abs)
836
if not tree.has_filename(to_name):
837
bailout("destination %r not in working directory" % to_abs)
838
to_dir_id = inv.path2id(to_name)
839
if to_dir_id == None and to_name != '':
840
bailout("destination %r is not a versioned directory" % to_name)
841
to_dir_ie = inv[to_dir_id]
842
if to_dir_ie.kind not in ('directory', 'root_directory'):
843
bailout("destination %r is not a directory" % to_abs)
844
845
to_idpath = Set(inv.get_idpath(to_dir_id))
846
847
for f in from_paths:
848
if not tree.has_filename(f):
849
bailout("%r does not exist in working tree" % f)
850
f_id = inv.path2id(f)
851
if f_id == None:
852
bailout("%r is not versioned" % f)
853
name_tail = splitpath(f)[-1]
854
dest_path = appendpath(to_name, name_tail)
855
if tree.has_filename(dest_path):
856
bailout("destination %r already exists" % dest_path)
857
if f_id in to_idpath:
858
bailout("can't move %r to a subdirectory of itself" % f)
859
860
# OK, so there's a race here, it's possible that someone will
861
# create a file in this interval and then the rename might be
862
# left half-done. But we should have caught most problems.
863
864
for f in from_paths:
865
name_tail = splitpath(f)[-1]
866
dest_path = appendpath(to_name, name_tail)
867
print "%s => %s" % (f, dest_path)
868
inv.rename(inv.path2id(f), to_dir_id, name_tail)
869
try:
870
os.rename(self.abspath(f), self.abspath(dest_path))
871
except OSError, e:
872
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
873
["rename rolled back"])
874
875
self._write_inventory(inv)
876
877
878
879
def show_status(self, show_all=False):
652
653
def show_status(branch, show_all=False):
880
654
"""Display single-line status for non-ignored working files.
881
655
882
656
The list is show sorted in order by file name.
889
663
A foo
890
664
>>> b.commit("add foo")
891
665
>>> b.show_status()
892
>>> os.unlink(b.abspath('foo'))
666
>>> os.unlink(b._rel('foo'))
893
667
>>> b.show_status()
894
668
D foo
895
669
896
TODO: Get state for single files.
670
671
:todo: Get state for single files.
672
673
:todo: Perhaps show a slash at the end of directory names.
674
897
675
"""
898
676
899
677
# We have to build everything into a list first so that it can
905
683
# Interesting case: the old ID for a file has been removed,
906
684
# but a new file has been created under that name.
907
685
908
old = self.basis_tree()
909
new = self.working_tree()
686
old = branch.basis_tree()
687
old_inv = old.inventory
688
new = branch.working_tree()
689
new_inv = new.inventory
910
690
911
691
for fs, fid, oldname, newname, kind in diff_trees(old, new):
912
692
if fs == 'R':
925
705
elif fs == '?':
926
706
show_status(fs, kind, newname)
927
707
else:
928
bailout("weird file state %r" % ((fs, fid),))
708
bailout("wierd file state %r" % ((fs, fid),))
929
709
930
710
931
711
940
720
>>> isdir(bd)
941
721
False
942
722
"""
943
def __init__(self, files=[], dirs=[]):
723
def __init__(self, files = []):
944
724
"""Make a test branch.
945
725
946
726
This creates a temporary directory and runs init-tree in it.
948
728
If any files are listed, they are created in the working copy.
949
729
"""
950
730
Branch.__init__(self, tempfile.mkdtemp(), init=True)
951
for d in dirs:
952
os.mkdir(self.abspath(d))
953
954
731
for f in files:
955
732
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
956
733
957
734
958
735
def __del__(self):
959
736
"""Destroy the test branch, removing the scratch directory."""
960
try:
961
shutil.rmtree(self.base)
962
except OSError:
963
# Work around for shutil.rmtree failing on Windows when
964
# readonly files are encountered
965
for root, dirs, files in os.walk(self.base, topdown=False):
966
for name in files:
967
os.chmod(os.path.join(root, name), 0700)
968
shutil.rmtree(self.base)
737
shutil.rmtree(self.base)
969
738
970
739
971
740
981
750
## mutter('check %r for control file' % ((head, tail), ))
982
751
if tail == bzrlib.BZRDIR:
983
752
return True
984
if filename == head:
985
break
986
753
filename = head
987
754
return False
988
755
995
762
return s
996
763
997
764
998
def gen_file_id(name):
765
def _gen_file_id(name):
999
766
"""Return new file id.
1000
767
1001
768
This should probably generate proper UUIDs, but for the moment we
1002
769
cope with just randomness because running uuidgen every time is
1003
770
slow."""
1004
idx = name.rfind('/')
1005
if idx != -1:
1006
name = name[idx+1 : ]
1007
idx = name.rfind('\\')
1008
if idx != -1:
1009
name = name[idx+1 : ]
1010
1011
name = name.lstrip('.')
1012
771
assert '/' not in name
772
while name[0] == '.':
773
name = name[1:]
1013
774
s = hexlify(rand_bytes(8))
1014
775
return '-'.join((name, compact_date(time.time()), s))
776
777
Loggerhead is a web-based interface for Breezy
Version: 2.0.1