« back to all changes in this revision
Viewing changes to bzrlib/changeset.py
- browse files at revision 521
- compare with another revision
- download diff
- download tarball
- view history from revision 521
- Committer: Martin Pool
- Date: 2005-05-17 07:01:47 UTC
- Revision ID: mbp@sourcefrog.net-20050517070147-c38da17418ea6711
- Add patch to give symlink support
- files added:
- bzrlib/mdiff.py
- files removed:
- HACKING
- bzrlib/export
- bzrlib/plugins
- bzrlib/store
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/transport
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- 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
- bzr *
- setup.py *
added
removed
bzrlib/changeset.py
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
"""Represent and apply a changeset.
18
19
Conflicts in applying a changeset are represented as exceptions.
20
21
This only handles the in-memory objects representing changesets, which are
22
primarily used by the merge code.
23
"""
24
25
16
import os.path
26
17
import errno
18
import patch
27
19
import stat
28
from tempfile import mkdtemp
29
from shutil import rmtree
30
from itertools import izip
31
32
from bzrlib.trace import mutter, warning
33
from bzrlib.osutils import rename, sha_file
34
import bzrlib
35
from bzrlib.errors import BzrCheckError
36
20
"""
21
Represent and apply a changeset
22
"""
37
23
__docformat__ = "restructuredtext"
38
24
39
25
NULL_ID = "!NULL"
40
26
41
class OldFailedTreeOp(Exception):
42
def __init__(self):
43
Exception.__init__(self, "bzr-tree-change contains files from a"
44
" previous failed merge operation.")
27
45
28
def invert_dict(dict):
46
29
newdict = {}
47
30
for (key,value) in dict.iteritems():
48
31
newdict[value] = key
49
32
return newdict
50
33
51
52
class ChangeExecFlag(object):
34
35
class PatchApply:
36
"""Patch application as a kind of content change"""
37
def __init__(self, contents):
38
"""Constructor.
39
40
:param contents: The text of the patch to apply
41
:type contents: str"""
42
self.contents = contents
43
44
def __eq__(self, other):
45
if not isinstance(other, PatchApply):
46
return False
47
elif self.contents != other.contents:
48
return False
49
else:
50
return True
51
52
def __ne__(self, other):
53
return not (self == other)
54
55
def apply(self, filename, conflict_handler, reverse=False):
56
"""Applies the patch to the specified file.
57
58
:param filename: the file to apply the patch to
59
:type filename: str
60
:param reverse: If true, apply the patch in reverse
61
:type reverse: bool
62
"""
63
input_name = filename+".orig"
64
try:
65
os.rename(filename, input_name)
66
except OSError, e:
67
if e.errno != errno.ENOENT:
68
raise
69
if conflict_handler.patch_target_missing(filename, self.contents)\
70
== "skip":
71
return
72
os.rename(filename, input_name)
73
74
75
status = patch.patch(self.contents, input_name, filename,
76
reverse)
77
os.chmod(filename, os.stat(input_name).st_mode)
78
if status == 0:
79
os.unlink(input_name)
80
elif status == 1:
81
conflict_handler.failed_hunks(filename)
82
83
84
class ChangeUnixPermissions:
53
85
"""This is two-way change, suitable for file modification, creation,
54
86
deletion"""
55
def __init__(self, old_exec_flag, new_exec_flag):
56
self.old_exec_flag = old_exec_flag
57
self.new_exec_flag = new_exec_flag
87
def __init__(self, old_mode, new_mode):
88
self.old_mode = old_mode
89
self.new_mode = new_mode
58
90
59
91
def apply(self, filename, conflict_handler, reverse=False):
60
92
if not reverse:
61
from_exec_flag = self.old_exec_flag
62
to_exec_flag = self.new_exec_flag
93
from_mode = self.old_mode
94
to_mode = self.new_mode
63
95
else:
64
from_exec_flag = self.new_exec_flag
65
to_exec_flag = self.old_exec_flag
96
from_mode = self.new_mode
97
to_mode = self.old_mode
66
98
try:
67
current_exec_flag = bool(os.stat(filename).st_mode & 0111)
99
current_mode = os.stat(filename).st_mode &0777
68
100
except OSError, e:
69
101
if e.errno == errno.ENOENT:
70
if conflict_handler.missing_for_exec_flag(filename) == "skip":
102
if conflict_handler.missing_for_chmod(filename) == "skip":
71
103
return
72
104
else:
73
current_exec_flag = from_exec_flag
105
current_mode = from_mode
74
106
75
if from_exec_flag is not None and current_exec_flag != from_exec_flag:
76
if conflict_handler.wrong_old_exec_flag(filename,
77
from_exec_flag, current_exec_flag) != "continue":
107
if from_mode is not None and current_mode != from_mode:
108
if conflict_handler.wrong_old_perms(filename, from_mode,
109
current_mode) != "continue":
78
110
return
79
111
80
if to_exec_flag is not None:
81
current_mode = os.stat(filename).st_mode
82
if to_exec_flag:
83
umask = os.umask(0)
84
os.umask(umask)
85
to_mode = current_mode | (0100 & ~umask)
86
# Enable x-bit for others only if they can read it.
87
if current_mode & 0004:
88
to_mode |= 0001 & ~umask
89
if current_mode & 0040:
90
to_mode |= 0010 & ~umask
91
else:
92
to_mode = current_mode & ~0111
112
if to_mode is not None:
93
113
try:
94
114
os.chmod(filename, to_mode)
95
115
except IOError, e:
96
116
if e.errno == errno.ENOENT:
97
conflict_handler.missing_for_exec_flag(filename)
117
conflict_handler.missing_for_chmod(filename)
98
118
99
119
def __eq__(self, other):
100
return (isinstance(other, ChangeExecFlag) and
101
self.old_exec_flag == other.old_exec_flag and
102
self.new_exec_flag == other.new_exec_flag)
120
if not isinstance(other, ChangeUnixPermissions):
121
return False
122
elif self.old_mode != other.old_mode:
123
return False
124
elif self.new_mode != other.new_mode:
125
return False
126
else:
127
return True
103
128
104
129
def __ne__(self, other):
105
130
return not (self == other)
106
131
107
108
132
def dir_create(filename, conflict_handler, reverse):
109
133
"""Creates the directory, or deletes it if reverse is true. Intended to be
110
134
used with ReplaceContents.
130
154
try:
131
155
os.rmdir(filename)
132
156
except OSError, e:
133
if e.errno != errno.ENOTEMPTY:
157
if e.errno != 39:
134
158
raise
135
159
if conflict_handler.rmdir_non_empty(filename) == "skip":
136
160
return
137
161
os.rmdir(filename)
138
162
163
164
139
165
140
class SymlinkCreate(object):
166
class SymlinkCreate:
141
167
"""Creates or deletes a symlink (for use with ReplaceContents)"""
142
168
def __init__(self, contents):
143
169
"""Constructor.
147
173
"""
148
174
self.target = contents
149
175
150
def __repr__(self):
151
return "SymlinkCreate(%s)" % self.target
152
153
176
def __call__(self, filename, conflict_handler, reverse):
154
177
"""Creates or destroys the symlink.
155
178
179
202
def __ne__(self, other):
180
203
return not (self == other)
181
204
182
class FileCreate(object):
205
class FileCreate:
183
206
"""Create or delete a file (for use with ReplaceContents)"""
184
207
def __init__(self, contents):
185
208
"""Constructor
237
260
238
261
239
262
240
class TreeFileCreate(object):
241
"""Create or delete a file (for use with ReplaceContents)"""
242
def __init__(self, tree, file_id):
243
"""Constructor
244
245
:param contents: The contents of the file to write
246
:type contents: str
247
"""
248
self.tree = tree
249
self.file_id = file_id
250
251
def __repr__(self):
252
return "TreeFileCreate(%s)" % self.file_id
253
254
def __eq__(self, other):
255
if not isinstance(other, TreeFileCreate):
256
return False
257
return self.tree.get_file_sha1(self.file_id) == \
258
other.tree.get_file_sha1(other.file_id)
259
260
def __ne__(self, other):
261
return not (self == other)
262
263
def write_file(self, filename):
264
outfile = file(filename, "wb")
265
for line in self.tree.get_file(self.file_id):
266
outfile.write(line)
267
268
def same_text(self, filename):
269
in_file = file(filename, "rb")
270
return sha_file(in_file) == self.tree.get_file_sha1(self.file_id)
271
272
def __call__(self, filename, conflict_handler, reverse):
273
"""Create or delete a file
274
275
:param filename: The name of the file to create
276
:type filename: str
277
:param reverse: Delete the file instead of creating it
278
:type reverse: bool
279
"""
280
if not reverse:
281
try:
282
self.write_file(filename)
283
except IOError, e:
284
if e.errno == errno.ENOENT:
285
if conflict_handler.missing_parent(filename)=="continue":
286
self.write_file(filename)
287
else:
288
raise
289
290
else:
291
try:
292
if not self.same_text(filename):
293
direction = conflict_handler.wrong_old_contents(filename,
294
self.tree.get_file(self.file_id).read())
295
if direction != "continue":
296
return
297
os.unlink(filename)
298
except IOError, e:
299
if e.errno != errno.ENOENT:
300
raise
301
if conflict_handler.missing_for_rm(filename, undo) == "skip":
302
return
303
304
305
306
263
def reversed(sequence):
307
264
max = len(sequence) - 1
308
265
for i in range(len(sequence)):
309
266
yield sequence[max - i]
310
267
311
class ReplaceContents(object):
268
class ReplaceContents:
312
269
"""A contents-replacement framework. It allows a file/directory/symlink to
313
270
be created, deleted, or replaced with another file/directory/symlink.
314
271
Arguments must be callable with (filename, reverse).
375
332
if mode is not None:
376
333
os.chmod(filename, mode)
377
334
378
def is_creation(self):
379
return self.new_contents is not None and self.old_contents is None
380
381
def is_deletion(self):
382
return self.old_contents is not None and self.new_contents is None
383
384
class ApplySequence(object):
335
class ApplySequence:
385
336
def __init__(self, changes=None):
386
337
self.changes = []
387
338
if changes is not None:
411
362
change.apply(filename, conflict_handler, reverse)
412
363
413
364
414
class Diff3Merge(object):
415
history_based = False
416
def __init__(self, file_id, base, other):
417
self.file_id = file_id
418
self.base = base
419
self.other = other
420
421
def is_creation(self):
422
return False
423
424
def is_deletion(self):
425
return False
365
class Diff3Merge:
366
def __init__(self, base_file, other_file):
367
self.base_file = base_file
368
self.other_file = other_file
426
369
427
370
def __eq__(self, other):
428
371
if not isinstance(other, Diff3Merge):
429
372
return False
430
return (self.base == other.base and
431
self.other == other.other and self.file_id == other.file_id)
373
return (self.base_file == other.base_file and
374
self.other_file == other.other_file)
432
375
433
376
def __ne__(self, other):
434
377
return not (self == other)
435
378
436
def dump_file(self, temp_dir, name, tree):
437
out_path = os.path.join(temp_dir, name)
438
out_file = file(out_path, "wb")
439
in_file = tree.get_file(self.file_id)
440
for line in in_file:
441
out_file.write(line)
442
return out_path
443
444
379
def apply(self, filename, conflict_handler, reverse=False):
445
import bzrlib.patch
446
temp_dir = mkdtemp(prefix="bzr-")
447
try:
448
new_file = filename+".new"
449
base_file = self.dump_file(temp_dir, "base", self.base)
450
other_file = self.dump_file(temp_dir, "other", self.other)
451
if not reverse:
452
base = base_file
453
other = other_file
454
else:
455
base = other_file
456
other = base_file
457
status = bzrlib.patch.diff3(new_file, filename, base, other)
458
if status == 0:
459
os.chmod(new_file, os.stat(filename).st_mode)
460
rename(new_file, filename)
461
return
462
else:
463
assert(status == 1)
464
def get_lines(filename):
465
my_file = file(filename, "rb")
466
lines = my_file.readlines()
467
my_file.close()
468
return lines
469
base_lines = get_lines(base)
470
other_lines = get_lines(other)
471
conflict_handler.merge_conflict(new_file, filename, base_lines,
472
other_lines)
473
finally:
474
rmtree(temp_dir)
380
new_file = filename+".new"
381
if not reverse:
382
base = self.base_file
383
other = self.other_file
384
else:
385
base = self.other_file
386
other = self.base_file
387
status = patch.diff3(new_file, filename, base, other)
388
if status == 0:
389
os.chmod(new_file, os.stat(filename).st_mode)
390
os.rename(new_file, filename)
391
return
392
else:
393
assert(status == 1)
394
conflict_handler.merge_conflict(new_file, filename, base, other)
475
395
476
396
477
397
def CreateDir():
510
430
"""
511
431
return ReplaceContents(FileCreate(contents), None)
512
432
513
def ReplaceFileContents(old_tree, new_tree, file_id):
433
def ReplaceFileContents(old_contents, new_contents):
514
434
"""Convenience fucntion to replace the contents of a file.
515
435
516
436
:param old_contents: The contents of the file to replace
520
440
:return: A ReplaceContents that will replace the contents of a file a file
521
441
:rtype: `ReplaceContents`
522
442
"""
523
return ReplaceContents(TreeFileCreate(old_tree, file_id),
524
TreeFileCreate(new_tree, file_id))
443
return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
525
444
526
445
def CreateSymlink(target):
527
446
"""Convenience fucntion to create a symlink.
633
552
if self.id == self.parent:
634
553
raise ParentIDIsSelf(self)
635
554
636
def __repr__(self):
555
def __str__(self):
637
556
return "ChangesetEntry(%s)" % self.id
638
557
639
__str__ = __repr__
640
641
558
def __get_dir(self):
642
559
if self.path is None:
643
560
return None
692
609
:param reverse: if true, the changeset is being applied in reverse
693
610
:rtype: bool
694
611
"""
695
return self.is_creation(not reverse)
612
return ((self.new_parent is None and not reverse) or
613
(self.parent is None and reverse))
696
614
697
615
def is_creation(self, reverse):
698
616
"""Return true if applying the entry would create a file/directory.
700
618
:param reverse: if true, the changeset is being applied in reverse
701
619
:rtype: bool
702
620
"""
703
if self.contents_change is None:
704
return False
705
if reverse:
706
return self.contents_change.is_deletion()
707
else:
708
return self.contents_change.is_creation()
621
return ((self.parent is None and not reverse) or
622
(self.new_parent is None and reverse))
709
623
710
624
def is_creation_or_deletion(self):
711
625
"""Return true if applying the entry would create or delete a
713
627
714
628
:rtype: bool
715
629
"""
716
return self.is_creation(False) or self.is_deletion(False)
630
return self.parent is None or self.new_parent is None
717
631
718
632
def get_cset_path(self, mod=False):
719
633
"""Determine the path of the entry according to the changeset.
739
653
return None
740
654
return self.path
741
655
742
def summarize_name(self, reverse=False):
656
def summarize_name(self, changeset, reverse=False):
743
657
"""Produce a one-line summary of the filename. Indicates renames as
744
658
old => new, indicates creation as None => new, indicates deletion as
745
659
old => None.
752
666
"""
753
667
orig_path = self.get_cset_path(False)
754
668
mod_path = self.get_cset_path(True)
755
if orig_path and orig_path.startswith('./'):
669
if orig_path is not None:
756
670
orig_path = orig_path[2:]
757
if mod_path and mod_path.startswith('./'):
671
if mod_path is not None:
758
672
mod_path = mod_path[2:]
759
673
if orig_path == mod_path:
760
674
return orig_path
776
690
:type reverse: bool
777
691
:rtype: str
778
692
"""
779
mutter("Finding new path for %s", self.summarize_name())
780
693
if reverse:
781
694
parent = self.parent
782
695
to_dir = self.dir
794
707
return None
795
708
796
709
if parent == NULL_ID or parent is None:
797
if to_name != u'.':
710
if to_name != '.':
798
711
raise SourceRootHasName(self, to_name)
799
712
else:
800
return u'.'
801
parent_entry = changeset.entries.get(parent)
802
if parent_entry is None:
713
return '.'
714
if from_dir == to_dir:
803
715
dir = os.path.dirname(id_map[self.id])
804
716
else:
805
mutter("path, new_path: %r %r", self.path, self.new_path)
717
parent_entry = changeset.entries[parent]
806
718
dir = parent_entry.get_new_path(id_map, changeset, reverse)
807
719
if from_name == to_name:
808
720
name = os.path.basename(id_map[self.id])
850
762
Exception.__init__(self, msg)
851
763
self.id = id
852
764
853
class Changeset(object):
765
class Changeset:
854
766
"""A set of changes to apply"""
855
767
def __init__(self):
856
768
self.entries = {}
891
803
:rtype: (List, List)
892
804
"""
893
805
source_entries = [x for x in changeset.entries.itervalues()
894
if x.needs_rename() or x.is_creation_or_deletion()]
806
if x.needs_rename()]
895
807
# these are done from longest path to shortest, to avoid deleting a
896
808
# parent before its children are deleted/renamed
897
809
def longest_to_shortest(entry):
914
826
my_sort(target_entries, shortest_to_longest)
915
827
return (source_entries, target_entries)
916
828
917
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir,
918
conflict_handler, reverse):
829
def rename_to_temp_delete(source_entries, inventory, dir, conflict_handler,
830
reverse):
919
831
"""Delete and rename entries as appropriate. Entries are renamed to temp
920
names. A map of id -> temp name (or None, for deletions) is returned.
832
names. A map of id -> temp name is returned.
921
833
922
834
:param source_entries: The entries to rename and delete
923
835
:type source_entries: List of `ChangesetEntry`
930
842
:return: a mapping of id to temporary name
931
843
:rtype: Dictionary
932
844
"""
845
temp_dir = os.path.join(dir, "temp")
933
846
temp_name = {}
934
847
for i in range(len(source_entries)):
935
848
entry = source_entries[i]
936
849
if entry.is_deletion(reverse):
937
850
path = os.path.join(dir, inventory[entry.id])
938
851
entry.apply(path, conflict_handler, reverse)
939
temp_name[entry.id] = None
940
852
941
elif entry.needs_rename():
942
if entry.is_creation(reverse):
943
continue
944
to_name = os.path.join(temp_dir, str(i))
853
else:
854
to_name = temp_dir+"/"+str(i)
945
855
src_path = inventory.get(entry.id)
946
856
if src_path is not None:
947
857
src_path = os.path.join(dir, src_path)
948
858
try:
949
rename(src_path, to_name)
859
os.rename(src_path, to_name)
950
860
temp_name[entry.id] = to_name
951
861
except OSError, e:
952
862
if e.errno != errno.ENOENT:
953
863
raise
954
if conflict_handler.missing_for_rename(src_path, to_name) \
955
== "skip":
864
if conflict_handler.missing_for_rename(src_path) == "skip":
956
865
continue
957
866
958
867
return temp_name
959
868
960
869
961
def rename_to_new_create(changed_inventory, target_entries, inventory,
962
changeset, dir, conflict_handler, reverse):
870
def rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
871
conflict_handler, reverse):
963
872
"""Rename entries with temp names to their final names, create new files.
964
873
965
:param changed_inventory: A mapping of id to temporary name
966
:type changed_inventory: Dictionary
874
:param temp_name: A mapping of id to temporary name
875
:type temp_name: Dictionary
967
876
:param target_entries: The entries to apply changes to
968
877
:type target_entries: List of `ChangesetEntry`
969
878
:param changeset: The changeset to apply
974
883
:type reverse: bool
975
884
"""
976
885
for entry in target_entries:
977
new_tree_path = entry.get_new_path(inventory, changeset, reverse)
978
if new_tree_path is None:
886
new_path = entry.get_new_path(inventory, changeset, reverse)
887
if new_path is None:
979
888
continue
980
new_path = os.path.join(dir, new_tree_path)
981
old_path = changed_inventory.get(entry.id)
982
if bzrlib.osutils.lexists(new_path):
889
new_path = os.path.join(dir, new_path)
890
old_path = temp_name.get(entry.id)
891
if os.path.exists(new_path):
983
892
if conflict_handler.target_exists(entry, new_path, old_path) == \
984
893
"skip":
985
894
continue
986
895
if entry.is_creation(reverse):
987
896
entry.apply(new_path, conflict_handler, reverse)
988
changed_inventory[entry.id] = new_tree_path
989
elif entry.needs_rename():
990
if entry.is_deletion(reverse):
991
continue
897
else:
992
898
if old_path is None:
993
899
continue
994
900
try:
995
mutter('rename %s to final name %s', old_path, new_path)
996
rename(old_path, new_path)
997
changed_inventory[entry.id] = new_tree_path
901
os.rename(old_path, new_path)
998
902
except OSError, e:
999
raise BzrCheckError('failed to rename %s to %s for changeset entry %s: %s'
1000
% (old_path, new_path, entry, e))
903
raise Exception ("%s is missing" % new_path)
1001
904
1002
905
class TargetExists(Exception):
1003
906
def __init__(self, entry, target):
1035
938
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
1036
939
self.this_path = this_path
1037
940
941
class MergePermissionConflict(Exception):
942
def __init__(self, this_path, base_path, other_path):
943
this_perms = os.stat(this_path).st_mode & 0755
944
base_perms = os.stat(base_path).st_mode & 0755
945
other_perms = os.stat(other_path).st_mode & 0755
946
msg = """Conflicting permission for %s
947
this: %o
948
base: %o
949
other: %o
950
""" % (this_path, this_perms, base_perms, other_perms)
951
self.this_path = this_path
952
self.base_path = base_path
953
self.other_path = other_path
954
Exception.__init__(self, msg)
955
1038
956
class WrongOldContents(Exception):
1039
957
def __init__(self, filename):
1040
958
msg = "Contents mismatch deleting %s" % filename
1041
959
self.filename = filename
1042
960
Exception.__init__(self, msg)
1043
961
1044
class WrongOldExecFlag(Exception):
1045
def __init__(self, filename, old_exec_flag, new_exec_flag):
1046
msg = "Executable flag missmatch on %s:\n" \
1047
"Expected %s, got %s." % (filename, old_exec_flag, new_exec_flag)
962
class WrongOldPermissions(Exception):
963
def __init__(self, filename, old_perms, new_perms):
964
msg = "Permission missmatch on %s:\n" \
965
"Expected 0%o, got 0%o." % (filename, old_perms, new_perms)
1048
966
self.filename = filename
1049
967
Exception.__init__(self, msg)
1050
968
1068
986
Exception.__init__(self, msg)
1069
987
self.filename = filename
1070
988
1071
class MissingForSetExec(Exception):
989
class MissingPermsFile(Exception):
1072
990
def __init__(self, filename):
1073
991
msg = "Attempt to change permissions on %s, which does not exist" %\
1074
992
filename
1083
1001
1084
1002
1085
1003
class MissingForRename(Exception):
1086
def __init__(self, filename, to_path):
1087
msg = "Attempt to move missing path %s to %s" % (filename, to_path)
1004
def __init__(self, filename):
1005
msg = "Attempt to move missing path %s" % (filename)
1088
1006
Exception.__init__(self, msg)
1089
1007
self.filename = filename
1090
1008
1091
class NewContentsConflict(Exception):
1092
def __init__(self, filename):
1093
msg = "Conflicting contents for new file %s" % (filename)
1094
Exception.__init__(self, msg)
1095
1096
class WeaveMergeConflict(Exception):
1097
def __init__(self, filename):
1098
msg = "Conflicting contents for file %s" % (filename)
1099
Exception.__init__(self, msg)
1100
1101
class ThreewayContentsConflict(Exception):
1102
def __init__(self, filename):
1103
msg = "Conflicting contents for file %s" % (filename)
1104
Exception.__init__(self, msg)
1105
1106
1107
class MissingForMerge(Exception):
1108
def __init__(self, filename):
1109
msg = "The file %s was modified, but does not exist in this tree"\
1110
% (filename)
1111
Exception.__init__(self, msg)
1112
1113
1114
class ExceptionConflictHandler(object):
1115
"""Default handler for merge exceptions.
1116
1117
This throws an error on any kind of conflict. Conflict handlers can
1118
descend from this class if they have a better way to handle some or
1119
all types of conflict.
1120
"""
1009
class ExceptionConflictHandler:
1010
def __init__(self, dir):
1011
self.dir = dir
1012
1121
1013
def missing_parent(self, pathname):
1122
1014
parent = os.path.dirname(pathname)
1123
1015
raise Exception("Parent directory missing for %s" % pathname)
1134
1026
def rename_conflict(self, id, this_name, base_name, other_name):
1135
1027
raise RenameConflict(id, this_name, base_name, other_name)
1136
1028
1137
def move_conflict(self, id, this_dir, base_dir, other_dir):
1029
def move_conflict(self, id, inventory):
1030
this_dir = inventory.this.get_dir(id)
1031
base_dir = inventory.base.get_dir(id)
1032
other_dir = inventory.other.get_dir(id)
1138
1033
raise MoveConflict(id, this_dir, base_dir, other_dir)
1139
1034
1140
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1035
def merge_conflict(self, new_file, this_path, base_path, other_path):
1141
1036
os.unlink(new_file)
1142
1037
raise MergeConflict(this_path)
1143
1038
1039
def permission_conflict(self, this_path, base_path, other_path):
1040
raise MergePermissionConflict(this_path, base_path, other_path)
1041
1144
1042
def wrong_old_contents(self, filename, expected_contents):
1145
1043
raise WrongOldContents(filename)
1146
1044
1147
1045
def rem_contents_conflict(self, filename, this_contents, base_contents):
1148
1046
raise RemoveContentsConflict(filename)
1149
1047
1150
def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
1151
raise WrongOldExecFlag(filename, old_exec_flag, new_exec_flag)
1048
def wrong_old_perms(self, filename, old_perms, new_perms):
1049
raise WrongOldPermissions(filename, old_perms, new_perms)
1152
1050
1153
1051
def rmdir_non_empty(self, filename):
1154
1052
raise DeletingNonEmptyDirectory(filename)
1159
1057
def patch_target_missing(self, filename, contents):
1160
1058
raise PatchTargetMissing(filename)
1161
1059
1162
def missing_for_exec_flag(self, filename):
1163
raise MissingForExecFlag(filename)
1060
def missing_for_chmod(self, filename):
1061
raise MissingPermsFile(filename)
1164
1062
1165
1063
def missing_for_rm(self, filename, change):
1166
1064
raise MissingForRm(filename)
1167
1065
1168
def missing_for_rename(self, filename, to_path):
1169
raise MissingForRename(filename, to_path)
1170
1171
def missing_for_merge(self, file_id, other_path):
1172
raise MissingForMerge(other_path)
1173
1174
def new_contents_conflict(self, filename, other_contents):
1175
raise NewContentsConflict(filename)
1176
1177
def weave_merge_conflict(self, filename, weave, other_i, out_file):
1178
raise WeaveMergeConflict(filename)
1179
1180
def threeway_contents_conflict(self, filename, this_contents,
1181
base_contents, other_contents):
1182
raise ThreewayContentsConflict(filename)
1183
1184
def finalize(self):
1185
pass
1066
def missing_for_rename(self, filename):
1067
raise MissingForRename(filename)
1186
1068
1187
1069
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1188
1070
reverse=False):
1200
1082
:rtype: Dictionary
1201
1083
"""
1202
1084
if conflict_handler is None:
1203
conflict_handler = ExceptionConflictHandler()
1204
temp_dir = os.path.join(dir, "bzr-tree-change")
1205
try:
1206
os.mkdir(temp_dir)
1207
except OSError, e:
1208
if e.errno == errno.EEXIST:
1209
try:
1210
os.rmdir(temp_dir)
1211
except OSError, e:
1212
if e.errno == errno.ENOTEMPTY:
1213
raise OldFailedTreeOp()
1214
os.mkdir(temp_dir)
1215
else:
1216
raise
1085
conflict_handler = ExceptionConflictHandler(dir)
1086
temp_dir = dir+"/temp"
1087
os.mkdir(temp_dir)
1217
1088
1218
1089
#apply changes that don't affect filenames
1219
1090
for entry in changeset.entries.itervalues():
1220
if not entry.is_creation_or_deletion() and not entry.is_boring():
1221
if entry.id not in inventory:
1222
warning("entry {%s} no longer present, can't be updated",
1223
entry.id)
1224
continue
1091
if not entry.is_creation_or_deletion():
1225
1092
path = os.path.join(dir, inventory[entry.id])
1226
1093
entry.apply(path, conflict_handler, reverse)
1227
1094
1232
1099
(source_entries, target_entries) = get_rename_entries(changeset, inventory,
1233
1100
reverse)
1234
1101
1235
changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
1236
temp_dir, conflict_handler,
1237
reverse)
1102
temp_name = rename_to_temp_delete(source_entries, inventory, dir,
1103
conflict_handler, reverse)
1238
1104
1239
rename_to_new_create(changed_inventory, target_entries, inventory,
1240
changeset, dir, conflict_handler, reverse)
1105
rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
1106
conflict_handler, reverse)
1241
1107
os.rmdir(temp_dir)
1242
return changed_inventory
1108
r_inventory = invert_dict(inventory)
1109
new_entries, removed_entries = get_inventory_change(inventory,
1110
r_inventory, changeset, reverse)
1111
new_inventory = {}
1112
for path, file_id in new_entries.iteritems():
1113
new_inventory[file_id] = path
1114
for file_id in removed_entries:
1115
new_inventory[file_id] = None
1116
return new_inventory
1243
1117
1244
1118
1245
1119
def apply_changeset_tree(cset, tree, reverse=False):
1246
1120
r_inventory = {}
1247
1121
for entry in tree.source_inventory().itervalues():
1248
1122
inventory[entry.id] = entry.path
1249
new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
1123
new_inventory = apply_changeset(cset, r_inventory, tree.root,
1250
1124
reverse=reverse)
1251
1125
new_entries, remove_entries = \
1252
1126
get_inventory_change(inventory, new_inventory, cset, reverse)
1256
1130
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1257
1131
new_entries = {}
1258
1132
remove_entries = []
1133
r_inventory = invert_dict(inventory)
1134
r_new_inventory = invert_dict(new_inventory)
1259
1135
for entry in cset.entries.itervalues():
1260
1136
if entry.needs_rename():
1261
new_path = entry.get_new_path(inventory, cset)
1262
if new_path is None:
1263
remove_entries.append(entry.id)
1137
old_path = r_inventory.get(entry.id)
1138
if old_path is not None:
1139
remove_entries.append(old_path)
1264
1140
else:
1265
new_entries[new_path] = entry.id
1141
new_path = entry.get_new_path(inventory, cset)
1142
if new_path is not None:
1143
new_entries[new_path] = entry.id
1266
1144
return new_entries, remove_entries
1267
1145
1268
1146
1387
1265
return new_meta
1388
1266
elif new_meta is None:
1389
1267
return old_meta
1390
elif (isinstance(old_meta, ChangeExecFlag) and
1391
isinstance(new_meta, ChangeExecFlag)):
1392
return ChangeExecFlag(old_meta.old_exec_flag, new_meta.new_exec_flag)
1268
elif isinstance(old_meta, ChangeUnixPermissions) and \
1269
isinstance(new_meta, ChangeUnixPermissions):
1270
return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
1393
1271
else:
1394
1272
return ApplySequence(old_meta, new_meta)
1395
1273
1400
1278
return False
1401
1279
return True
1402
1280
1403
class UnsupportedFiletype(Exception):
1404
def __init__(self, kind, full_path):
1405
msg = "The file \"%s\" is a %s, which is not a supported filetype." \
1406
% (full_path, kind)
1281
class UnsuppportedFiletype(Exception):
1282
def __init__(self, full_path, stat_result):
1283
msg = "The file \"%s\" is not a supported filetype." % full_path
1407
1284
Exception.__init__(self, msg)
1408
1285
self.full_path = full_path
1409
self.kind = kind
1410
1411
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1412
return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1413
1286
self.stat_result = stat_result
1287
1288
def generate_changeset(tree_a, tree_b, inventory_a=None, inventory_b=None):
1289
return ChangesetGenerator(tree_a, tree_b, inventory_a, inventory_b)()
1414
1290
1415
1291
class ChangesetGenerator(object):
1416
def __init__(self, tree_a, tree_b, interesting_ids=None):
1292
def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
1417
1293
object.__init__(self)
1418
1294
self.tree_a = tree_a
1419
1295
self.tree_b = tree_b
1420
self._interesting_ids = interesting_ids
1296
if inventory_a is not None:
1297
self.inventory_a = inventory_a
1298
else:
1299
self.inventory_a = tree_a.inventory()
1300
if inventory_b is not None:
1301
self.inventory_b = inventory_b
1302
else:
1303
self.inventory_b = tree_b.inventory()
1304
self.r_inventory_a = self.reverse_inventory(self.inventory_a)
1305
self.r_inventory_b = self.reverse_inventory(self.inventory_b)
1421
1306
1422
def iter_both_tree_ids(self):
1423
for file_id in self.tree_a:
1424
yield file_id
1425
for file_id in self.tree_b:
1426
if file_id not in self.tree_a:
1427
yield file_id
1307
def reverse_inventory(self, inventory):
1308
r_inventory = {}
1309
for entry in inventory.itervalues():
1310
if entry.id is None:
1311
continue
1312
r_inventory[entry.id] = entry
1313
return r_inventory
1428
1314
1429
1315
def __call__(self):
1430
1316
cset = Changeset()
1431
for file_id in self.iter_both_tree_ids():
1432
cs_entry = self.make_entry(file_id)
1317
for entry in self.inventory_a.itervalues():
1318
if entry.id is None:
1319
continue
1320
cs_entry = self.make_entry(entry.id)
1433
1321
if cs_entry is not None and not cs_entry.is_boring():
1434
1322
cset.add_entry(cs_entry)
1435
1323
1324
for entry in self.inventory_b.itervalues():
1325
if entry.id is None:
1326
continue
1327
if not self.r_inventory_a.has_key(entry.id):
1328
cs_entry = self.make_entry(entry.id)
1329
if cs_entry is not None and not cs_entry.is_boring():
1330
cset.add_entry(cs_entry)
1436
1331
for entry in list(cset.entries.itervalues()):
1437
1332
if entry.parent != entry.new_parent:
1438
1333
if not cset.entries.has_key(entry.parent) and\
1446
1341
cset.add_entry(parent_entry)
1447
1342
return cset
1448
1343
1449
def iter_inventory(self, tree):
1450
for file_id in tree:
1451
yield self.get_entry(file_id, tree)
1452
1453
def get_entry(self, file_id, tree):
1454
if not tree.has_or_had_id(file_id):
1455
return None
1456
return tree.inventory[file_id]
1457
1458
def get_entry_parent(self, entry):
1459
if entry is None:
1460
return None
1461
return entry.parent_id
1462
1463
def get_path(self, file_id, tree):
1464
if not tree.has_or_had_id(file_id):
1465
return None
1466
path = tree.id2path(file_id)
1467
if path == '':
1468
return './.'
1469
else:
1470
return path
1471
1472
def make_basic_entry(self, file_id, only_interesting):
1473
entry_a = self.get_entry(file_id, self.tree_a)
1474
entry_b = self.get_entry(file_id, self.tree_b)
1344
def get_entry_parent(self, entry, inventory):
1345
if entry is None:
1346
return None
1347
if entry.path == "./.":
1348
return NULL_ID
1349
dirname = os.path.dirname(entry.path)
1350
if dirname == ".":
1351
dirname = "./."
1352
parent = inventory[dirname]
1353
return parent.id
1354
1355
def get_paths(self, entry, tree):
1356
if entry is None:
1357
return (None, None)
1358
full_path = tree.readonly_path(entry.id)
1359
if entry.path == ".":
1360
return ("", full_path)
1361
return (entry.path, full_path)
1362
1363
def make_basic_entry(self, id, only_interesting):
1364
entry_a = self.r_inventory_a.get(id)
1365
entry_b = self.r_inventory_b.get(id)
1475
1366
if only_interesting and not self.is_interesting(entry_a, entry_b):
1476
return None
1477
parent = self.get_entry_parent(entry_a)
1478
path = self.get_path(file_id, self.tree_a)
1479
cs_entry = ChangesetEntry(file_id, parent, path)
1480
new_parent = self.get_entry_parent(entry_b)
1481
1482
new_path = self.get_path(file_id, self.tree_b)
1367
return (None, None, None)
1368
parent = self.get_entry_parent(entry_a, self.inventory_a)
1369
(path, full_path_a) = self.get_paths(entry_a, self.tree_a)
1370
cs_entry = ChangesetEntry(id, parent, path)
1371
new_parent = self.get_entry_parent(entry_b, self.inventory_b)
1372
1373
1374
(new_path, full_path_b) = self.get_paths(entry_b, self.tree_b)
1483
1375
1484
1376
cs_entry.new_path = new_path
1485
1377
cs_entry.new_parent = new_parent
1486
return cs_entry
1378
return (cs_entry, full_path_a, full_path_b)
1487
1379
1488
1380
def is_interesting(self, entry_a, entry_b):
1489
if self._interesting_ids is None:
1490
return True
1491
1381
if entry_a is not None:
1492
file_id = entry_a.file_id
1493
elif entry_b is not None:
1494
file_id = entry_b.file_id
1495
else:
1496
return False
1497
return file_id in self._interesting_ids
1382
if entry_a.interesting:
1383
return True
1384
if entry_b is not None:
1385
if entry_b.interesting:
1386
return True
1387
return False
1498
1388
1499
1389
def make_boring_entry(self, id):
1500
cs_entry = self.make_basic_entry(id, only_interesting=False)
1390
(cs_entry, full_path_a, full_path_b) = \
1391
self.make_basic_entry(id, only_interesting=False)
1501
1392
if cs_entry.is_creation_or_deletion():
1502
1393
return self.make_entry(id, only_interesting=False)
1503
1394
else:
1505
1396
1506
1397
1507
1398
def make_entry(self, id, only_interesting=True):
1508
cs_entry = self.make_basic_entry(id, only_interesting)
1399
(cs_entry, full_path_a, full_path_b) = \
1400
self.make_basic_entry(id, only_interesting)
1509
1401
1510
1402
if cs_entry is None:
1511
1403
return None
1512
1513
cs_entry.metadata_change = self.make_exec_flag_change(id)
1514
1515
if id in self.tree_a and id in self.tree_b:
1516
a_sha1 = self.tree_a.get_file_sha1(id)
1517
b_sha1 = self.tree_b.get_file_sha1(id)
1518
if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1519
return cs_entry
1520
1521
cs_entry.contents_change = self.make_contents_change(id)
1404
1405
stat_a = self.lstat(full_path_a)
1406
stat_b = self.lstat(full_path_b)
1407
if stat_b is None:
1408
cs_entry.new_parent = None
1409
cs_entry.new_path = None
1410
1411
cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1412
cs_entry.contents_change = self.make_contents_change(full_path_a,
1413
stat_a,
1414
full_path_b,
1415
stat_b)
1522
1416
return cs_entry
1523
1417
1524
def make_exec_flag_change(self, file_id):
1525
exec_flag_a = exec_flag_b = None
1526
if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
1527
exec_flag_a = self.tree_a.is_executable(file_id)
1528
1529
if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
1530
exec_flag_b = self.tree_b.is_executable(file_id)
1531
1532
if exec_flag_a == exec_flag_b:
1533
return None
1534
return ChangeExecFlag(exec_flag_a, exec_flag_b)
1535
1536
def make_contents_change(self, file_id):
1537
a_contents = get_contents(self.tree_a, file_id)
1538
b_contents = get_contents(self.tree_b, file_id)
1418
def make_mode_change(self, stat_a, stat_b):
1419
mode_a = None
1420
if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
1421
mode_a = stat_a.st_mode & 0777
1422
mode_b = None
1423
if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
1424
mode_b = stat_b.st_mode & 0777
1425
if mode_a == mode_b:
1426
return None
1427
return ChangeUnixPermissions(mode_a, mode_b)
1428
1429
def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
1430
if stat_a is None and stat_b is None:
1431
return None
1432
if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
1433
stat.S_ISDIR(stat_b.st_mode):
1434
return None
1435
if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
1436
stat.S_ISREG(stat_b.st_mode):
1437
if stat_a.st_ino == stat_b.st_ino and \
1438
stat_a.st_dev == stat_b.st_dev:
1439
return None
1440
if file(full_path_a, "rb").read() == \
1441
file(full_path_b, "rb").read():
1442
return None
1443
1444
patch_contents = patch.diff(full_path_a,
1445
file(full_path_b, "rb").read())
1446
if patch_contents is None:
1447
return None
1448
return PatchApply(patch_contents)
1449
1450
a_contents = self.get_contents(stat_a, full_path_a)
1451
b_contents = self.get_contents(stat_b, full_path_b)
1539
1452
if a_contents == b_contents:
1540
1453
return None
1541
1454
return ReplaceContents(a_contents, b_contents)
1542
1455
1456
def get_contents(self, stat_result, full_path):
1457
if stat_result is None:
1458
return None
1459
elif stat.S_ISREG(stat_result.st_mode):
1460
return FileCreate(file(full_path, "rb").read())
1461
elif stat.S_ISDIR(stat_result.st_mode):
1462
return dir_create
1463
elif stat.S_ISLNK(stat_result.st_mode):
1464
return SymlinkCreate(os.readlink(full_path))
1465
else:
1466
raise UnsupportedFiletype(full_path, stat_result)
1543
1467
1544
def get_contents(tree, file_id):
1545
"""Return the appropriate contents to create a copy of file_id from tree"""
1546
if file_id not in tree:
1547
return None
1548
kind = tree.kind(file_id)
1549
if kind == "file":
1550
return TreeFileCreate(tree, file_id)
1551
elif kind in ("directory", "root_directory"):
1552
return dir_create
1553
elif kind == "symlink":
1554
return SymlinkCreate(tree.get_symlink_target(file_id))
1555
else:
1556
raise UnsupportedFiletype(kind, tree.id2path(file_id))
1468
def lstat(self, full_path):
1469
stat_result = None
1470
if full_path is not None:
1471
try:
1472
stat_result = os.lstat(full_path)
1473
except OSError, e:
1474
if e.errno != errno.ENOENT:
1475
raise
1476
return stat_result
1557
1477
1558
1478
1559
1479
def full_path(entry, tree):
1560
return os.path.join(tree.basedir, entry.path)
1480
return os.path.join(tree.root, entry.path)
1561
1481
1562
1482
def new_delete_entry(entry, tree, inventory, delete):
1563
1483
if entry.path == "":
1579
1499
1580
1500
1581
1501
1582
# XXX: Can't we unify this with the regular inventory object
1583
class Inventory(object):
1502
1503
class Inventory:
1584
1504
def __init__(self, inventory):
1585
1505
self.inventory = inventory
1586
1506
self.rinventory = None
1594
1514
return self.inventory.get(id)
1595
1515
1596
1516
def get_name(self, id):
1597
path = self.get_path(id)
1598
if path is None:
1599
return None
1600
else:
1601
return os.path.basename(path)
1517
return os.path.basename(self.get_path(id))
1602
1518
1603
1519
def get_dir(self, id):
1604
1520
path = self.get_path(id)
1605
1521
if path == "":
1606
1522
return None
1607
if path is None:
1608
return None
1609
1523
return os.path.dirname(path)
1610
1524
1611
1525
def get_parent(self, id):
1612
if self.get_path(id) is None:
1613
return None
1614
1526
directory = self.get_dir(id)
1615
1527
if directory == '.':
1616
directory = u'./.'
1528
directory = './.'
1617
1529
if directory is None:
1618
1530
return NULL_ID
1619
1531
return self.get_rinventory().get(directory)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1