« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 228
- compare with another revision
- download diff
- download tarball
- view history from revision 228
- Committer: mbp at sourcefrog
- Date: 2005-04-09 06:36:40 UTC
- Revision ID: mbp@sourcefrog.net-20050409063640-728d43dff50e91d8c09c83e3
update rsync exclude patterns
- files added:
- .rsyncexclude
- elementtree
- urlgrabber
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
1
# Copyright (C) 2005 Canonical Ltd
3
2
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
29
28
from inventory import InventoryEntry, Inventory
30
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
31
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
32
joinpath, sha_string, file_kind, local_time_offset
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
33
32
from store import ImmutableStore
34
33
from revision import Revision
35
from errors import bailout
34
from errors import bailout, BzrError
36
35
from textui import show_status
37
36
from diff import diff_trees
38
37
41
40
42
41
43
42
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
44
68
45
69
46
70
######################################################################
62
86
63
87
:todo: mkdir() method.
64
88
"""
65
def __init__(self, base, init=False):
89
def __init__(self, base, init=False, find_root=True):
66
90
"""Create new branch object at a particular location.
67
91
68
92
:param base: Base directory for the branch.
69
93
70
94
:param init: If True, create new control files in a previously
71
95
unversioned directory. If False, the branch must already
72
96
be versioned.
73
97
98
:param find_root: If true and init is false, find the root of the
99
existing branch containing base.
100
74
101
In the test suite, creation of new trees is tested using the
75
102
`ScratchBranch` class.
76
103
"""
77
self.base = os.path.realpath(base)
78
104
if init:
105
self.base = os.path.realpath(base)
79
106
self._make_control()
107
elif find_root:
108
self.base = find_branch_root(base)
80
109
else:
110
self.base = os.path.realpath(base)
81
111
if not isdir(self.controlfilename('.')):
82
112
bailout("not a bzr branch: %s" % quotefn(base),
83
113
['use "bzr init" to initialize a new working tree',
84
114
'current bzr can only operate from top-of-tree'])
85
self._check_format()
115
self._check_format()
86
116
87
117
self.text_store = ImmutableStore(self.controlfilename('text-store'))
88
118
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
96
126
__repr__ = __str__
97
127
98
128
99
def _rel(self, name):
100
"""Return filename relative to branch top"""
129
def abspath(self, name):
130
"""Return absolute filename for something in the branch"""
101
131
return os.path.join(self.base, name)
102
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
103
146
104
147
def controlfilename(self, file_or_path):
105
148
"""Return location relative to branch."""
118
161
self.controlfile('README', 'w').write(
119
162
"This is a Bazaar-NG control directory.\n"
120
163
"Do not change any files in this directory.")
121
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
164
self.controlfile('branch-format', 'wb').write(BZR_BRANCH_FORMAT)
122
165
for d in ('text-store', 'inventory-store', 'revision-store'):
123
166
os.mkdir(self.controlfilename(d))
124
167
for f in ('revision-history', 'merged-patches',
135
178
136
179
In the future, we might need different in-memory Branch
137
180
classes to support downlevel branches. But not yet.
138
"""
139
# read in binary mode to detect newline wierdness.
181
"""
182
# This ignores newlines so that we can open branches created
183
# on Windows from Linux and so on. I think it might be better
184
# to always make all internal files in unix format.
140
185
fmt = self.controlfile('branch-format', 'rb').read()
186
fmt.replace('\r\n', '')
141
187
if fmt != BZR_BRANCH_FORMAT:
142
188
bailout('sorry, branch format %r not supported' % fmt,
143
189
['use a different bzr version',
160
206
will be committed to the next revision.
161
207
"""
162
208
## TODO: factor out to atomicfile? is rename safe on windows?
209
## TODO: Maybe some kind of clean/dirty marker on inventory?
163
210
tmpfname = self.controlfilename('inventory.tmp')
164
211
tmpf = file(tmpfname, 'w')
165
212
inv.write_xml(tmpf)
166
213
tmpf.close()
167
os.rename(tmpfname, self.controlfilename('inventory'))
214
inv_fname = self.controlfilename('inventory')
215
if sys.platform == 'win32':
216
os.remove(inv_fname)
217
os.rename(tmpfname, inv_fname)
168
218
mutter('wrote working inventory')
169
219
170
220
228
278
if len(fp) == 0:
229
279
bailout("cannot add top-level %r" % f)
230
280
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))
281
fullpath = os.path.normpath(self.abspath(f))
282
283
try:
284
kind = file_kind(fullpath)
285
except OSError:
286
# maybe something better?
287
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
288
289
if kind != 'file' and kind != 'directory':
290
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
291
292
file_id = gen_file_id(f)
293
inv.add_path(f, kind=kind, file_id=file_id)
294
252
295
if verbose:
253
296
show_status('A', kind, quotefn(f))
254
297
255
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
256
% (f, file_id, kind, parent_id))
298
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
299
257
300
self._write_inventory(inv)
258
301
259
302
303
def print_file(self, file, revno):
304
"""Print `file` to stdout."""
305
tree = self.revision_tree(self.lookup_revision(revno))
306
# use inventory as it was in that revision
307
file_id = tree.inventory.path2id(file)
308
if not file_id:
309
bailout("%r is not present in revision %d" % (file, revno))
310
tree.print_file(file_id)
311
260
312
261
313
def remove(self, files, verbose=False):
262
314
"""Mark nominated files for removal from the inventory.
388
440
389
441
entry = entry.copy()
390
442
391
p = self._rel(path)
443
p = self.abspath(path)
392
444
file_id = entry.file_id
393
445
mutter('commit prep file %s, id %r ' % (p, file_id))
394
446
434
486
entry.text_id)
435
487
436
488
else:
437
entry.text_id = _gen_file_id(entry.name)
489
entry.text_id = gen_file_id(entry.name)
438
490
self.text_store.add(content, entry.text_id)
439
491
mutter(' stored with text_id {%s}' % entry.text_id)
440
492
if verbose:
442
494
state = 'A'
443
495
elif (old_ie.name == entry.name
444
496
and old_ie.parent_id == entry.parent_id):
497
state = 'M'
498
else:
445
499
state = 'R'
446
else:
447
state = 'M'
448
500
449
501
show_status(state, entry.kind, quotefn(path))
450
502
504
556
mutter("committing patch r%d" % (self.revno() + 1))
505
557
506
558
mutter("append to revision-history")
507
self.controlfile('revision-history', 'at').write(rev_id + '\n')
559
f = self.controlfile('revision-history', 'at')
560
f.write(rev_id + '\n')
561
f.close()
508
562
509
mutter("done!")
563
if verbose:
564
note("commited r%d" % self.revno())
510
565
511
566
512
567
def get_revision(self, revision_id):
568
623
ph = self.revision_history()
569
624
if ph:
570
625
return ph[-1]
571
626
else:
627
return None
628
572
629
573
630
def lookup_revision(self, revno):
574
631
"""Return revision hash for revision number."""
579
636
# list is 0-based; revisions are 1-based
580
637
return self.revision_history()[revno-1]
581
638
except IndexError:
582
bailout("no such revision %s" % revno)
639
raise BzrError("no such revision %s" % revno)
583
640
584
641
585
642
def revision_tree(self, revision_id):
655
712
precursor = p
656
713
657
714
658
659
def show_status(branch, show_all=False):
715
def rename_one(self, from_rel, to_rel):
716
tree = self.working_tree()
717
inv = tree.inventory
718
if not tree.has_filename(from_rel):
719
bailout("can't rename: old working file %r does not exist" % from_rel)
720
if tree.has_filename(to_rel):
721
bailout("can't rename: new working file %r already exists" % to_rel)
722
723
file_id = inv.path2id(from_rel)
724
if file_id == None:
725
bailout("can't rename: old name %r is not versioned" % from_rel)
726
727
if inv.path2id(to_rel):
728
bailout("can't rename: new name %r is already versioned" % to_rel)
729
730
to_dir, to_tail = os.path.split(to_rel)
731
to_dir_id = inv.path2id(to_dir)
732
if to_dir_id == None and to_dir != '':
733
bailout("can't determine destination directory id for %r" % to_dir)
734
735
mutter("rename_one:")
736
mutter(" file_id {%s}" % file_id)
737
mutter(" from_rel %r" % from_rel)
738
mutter(" to_rel %r" % to_rel)
739
mutter(" to_dir %r" % to_dir)
740
mutter(" to_dir_id {%s}" % to_dir_id)
741
742
inv.rename(file_id, to_dir_id, to_tail)
743
744
print "%s => %s" % (from_rel, to_rel)
745
746
from_abs = self.abspath(from_rel)
747
to_abs = self.abspath(to_rel)
748
try:
749
os.rename(from_abs, to_abs)
750
except OSError, e:
751
bailout("failed to rename %r to %r: %s"
752
% (from_abs, to_abs, e[1]),
753
["rename rolled back"])
754
755
self._write_inventory(inv)
756
757
758
759
def move(self, from_paths, to_name):
760
"""Rename files.
761
762
to_name must exist as a versioned directory.
763
764
If to_name exists and is a directory, the files are moved into
765
it, keeping their old names. If it is a directory,
766
767
Note that to_name is only the last component of the new name;
768
this doesn't change the directory.
769
"""
770
## TODO: Option to move IDs only
771
assert not isinstance(from_paths, basestring)
772
tree = self.working_tree()
773
inv = tree.inventory
774
to_abs = self.abspath(to_name)
775
if not isdir(to_abs):
776
bailout("destination %r is not a directory" % to_abs)
777
if not tree.has_filename(to_name):
778
bailout("destination %r not in working directory" % to_abs)
779
to_dir_id = inv.path2id(to_name)
780
if to_dir_id == None and to_name != '':
781
bailout("destination %r is not a versioned directory" % to_name)
782
to_dir_ie = inv[to_dir_id]
783
if to_dir_ie.kind not in ('directory', 'root_directory'):
784
bailout("destination %r is not a directory" % to_abs)
785
786
to_idpath = Set(inv.get_idpath(to_dir_id))
787
788
for f in from_paths:
789
if not tree.has_filename(f):
790
bailout("%r does not exist in working tree" % f)
791
f_id = inv.path2id(f)
792
if f_id == None:
793
bailout("%r is not versioned" % f)
794
name_tail = splitpath(f)[-1]
795
dest_path = appendpath(to_name, name_tail)
796
if tree.has_filename(dest_path):
797
bailout("destination %r already exists" % dest_path)
798
if f_id in to_idpath:
799
bailout("can't move %r to a subdirectory of itself" % f)
800
801
# OK, so there's a race here, it's possible that someone will
802
# create a file in this interval and then the rename might be
803
# left half-done. But we should have caught most problems.
804
805
for f in from_paths:
806
name_tail = splitpath(f)[-1]
807
dest_path = appendpath(to_name, name_tail)
808
print "%s => %s" % (f, dest_path)
809
inv.rename(inv.path2id(f), to_dir_id, name_tail)
810
try:
811
os.rename(self.abspath(f), self.abspath(dest_path))
812
except OSError, e:
813
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
814
["rename rolled back"])
815
816
self._write_inventory(inv)
817
818
819
820
def show_status(self, show_all=False):
660
821
"""Display single-line status for non-ignored working files.
661
822
662
823
The list is show sorted in order by file name.
669
830
A foo
670
831
>>> b.commit("add foo")
671
832
>>> b.show_status()
672
>>> os.unlink(b._rel('foo'))
833
>>> os.unlink(b.abspath('foo'))
673
834
>>> b.show_status()
674
835
D foo
675
836
689
850
# Interesting case: the old ID for a file has been removed,
690
851
# but a new file has been created under that name.
691
852
692
old = branch.basis_tree()
693
old_inv = old.inventory
694
new = branch.working_tree()
695
new_inv = new.inventory
853
old = self.basis_tree()
854
new = self.working_tree()
696
855
697
856
for fs, fid, oldname, newname, kind in diff_trees(old, new):
698
857
if fs == 'R':
726
885
>>> isdir(bd)
727
886
False
728
887
"""
729
def __init__(self, files = []):
888
def __init__(self, files=[], dirs=[]):
730
889
"""Make a test branch.
731
890
732
891
This creates a temporary directory and runs init-tree in it.
734
893
If any files are listed, they are created in the working copy.
735
894
"""
736
895
Branch.__init__(self, tempfile.mkdtemp(), init=True)
896
for d in dirs:
897
os.mkdir(self.abspath(d))
898
737
899
for f in files:
738
900
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
739
901
740
902
741
903
def __del__(self):
742
904
"""Destroy the test branch, removing the scratch directory."""
743
shutil.rmtree(self.base)
905
try:
906
shutil.rmtree(self.base)
907
except OSError:
908
# Work around for shutil.rmtree failing on Windows when
909
# readonly files are encountered
910
for root, dirs, files in os.walk(self.base, topdown=False):
911
for name in files:
912
os.chmod(os.path.join(root, name), 0700)
913
shutil.rmtree(self.base)
744
914
745
915
746
916
756
926
## mutter('check %r for control file' % ((head, tail), ))
757
927
if tail == bzrlib.BZRDIR:
758
928
return True
929
if filename == head:
930
break
759
931
filename = head
760
932
return False
761
933
768
940
return s
769
941
770
942
771
def _gen_file_id(name):
943
def gen_file_id(name):
772
944
"""Return new file id.
773
945
774
946
This should probably generate proper UUIDs, but for the moment we
775
947
cope with just randomness because running uuidgen every time is
776
948
slow."""
777
assert '/' not in name
778
while name[0] == '.':
779
name = name[1:]
949
idx = name.rfind('/')
950
if idx != -1:
951
name = name[idx+1 : ]
952
953
name = name.lstrip('.')
954
780
955
s = hexlify(rand_bytes(8))
781
956
return '-'.join((name, compact_date(time.time()), s))
782
957
Loggerhead is a web-based interface for Breezy
Version: 2.0.1