← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/changeset.py

  • Committer: Martin Pool
  • Date: 2005-08-25 05:58:05 UTC
  • mfrom: (974.1.36)
  • Revision ID: mbp@sourcefrog.net-20050825055805-8c892bc3c2d75131
- merge aaron's merge improvements:

  * When merging, pull in all missing revisions from the source
    branch. 

  * Detect common ancestors by looking at the whole ancestry graph, 
    rather than just mainline history.

  Some changes to reconcile this with parallel updates to the test and
  trace code.

aaron.bentley@utoronto.ca-20050823052551-f3401a8b57d9126f

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/changeset.py
17
17
import errno
18
18
import patch
19
19
import stat
20
 
from tempfile import mkdtemp
21
 
from shutil import rmtree
22
20
from bzrlib.trace import mutter
23
 
from bzrlib.osutils import rename, sha_file
24
 
import bzrlib
25
 
from itertools import izip
26
21
 
27
22
# XXX: mbp: I'm not totally convinced that we should handle conflicts
28
23
# as part of changeset application, rather than only in the merge
47
42
        newdict[value] = key
48
43
    return newdict
49
44
 
 
45
 
50
46
       
51
 
class ChangeExecFlag(object):
 
47
class ChangeUnixPermissions(object):
52
48
    """This is two-way change, suitable for file modification, creation,
53
49
    deletion"""
54
 
    def __init__(self, old_exec_flag, new_exec_flag):
55
 
        self.old_exec_flag = old_exec_flag
56
 
        self.new_exec_flag = new_exec_flag
 
50
    def __init__(self, old_mode, new_mode):
 
51
        self.old_mode = old_mode
 
52
        self.new_mode = new_mode
57
53
 
58
54
    def apply(self, filename, conflict_handler, reverse=False):
59
55
        if not reverse:
60
 
            from_exec_flag = self.old_exec_flag
61
 
            to_exec_flag = self.new_exec_flag
 
56
            from_mode = self.old_mode
 
57
            to_mode = self.new_mode
62
58
        else:
63
 
            from_exec_flag = self.new_exec_flag
64
 
            to_exec_flag = self.old_exec_flag
 
59
            from_mode = self.new_mode
 
60
            to_mode = self.old_mode
65
61
        try:
66
 
            current_exec_flag = bool(os.stat(filename).st_mode & 0111)
 
62
            current_mode = os.stat(filename).st_mode &0777
67
63
        except OSError, e:
68
64
            if e.errno == errno.ENOENT:
69
 
                if conflict_handler.missing_for_exec_flag(filename) == "skip":
 
65
                if conflict_handler.missing_for_chmod(filename) == "skip":
70
66
                    return
71
67
                else:
72
 
                    current_exec_flag = from_exec_flag
 
68
                    current_mode = from_mode
73
69
 
74
 
        if from_exec_flag is not None and current_exec_flag != from_exec_flag:
75
 
            if conflict_handler.wrong_old_exec_flag(filename,
76
 
                        from_exec_flag, current_exec_flag) != "continue":
 
70
        if from_mode is not None and current_mode != from_mode:
 
71
            if conflict_handler.wrong_old_perms(filename, from_mode, 
 
72
                                                current_mode) != "continue":
77
73
                return
78
74
 
79
 
        if to_exec_flag is not None:
80
 
            current_mode = os.stat(filename).st_mode
81
 
            if to_exec_flag:
82
 
                umask = os.umask(0)
83
 
                os.umask(umask)
84
 
                to_mode = current_mode | (0100 & ~umask)
85
 
                # Enable x-bit for others only if they can read it.
86
 
                if current_mode & 0004:
87
 
                    to_mode |= 0001 & ~umask
88
 
                if current_mode & 0040:
89
 
                    to_mode |= 0010 & ~umask
90
 
            else:
91
 
                to_mode = current_mode & ~0111
 
75
        if to_mode is not None:
92
76
            try:
93
77
                os.chmod(filename, to_mode)
94
78
            except IOError, e:
95
79
                if e.errno == errno.ENOENT:
96
 
                    conflict_handler.missing_for_exec_flag(filename)
 
80
                    conflict_handler.missing_for_chmod(filename)
97
81
 
98
82
    def __eq__(self, other):
99
 
        return (isinstance(other, ChangeExecFlag) and
100
 
                self.old_exec_flag == other.old_exec_flag and
101
 
                self.new_exec_flag == other.new_exec_flag)
 
83
        if not isinstance(other, ChangeUnixPermissions):
 
84
            return False
 
85
        elif self.old_mode != other.old_mode:
 
86
            return False
 
87
        elif self.new_mode != other.new_mode:
 
88
            return False
 
89
        else:
 
90
            return True
102
91
 
103
92
    def __ne__(self, other):
104
93
        return not (self == other)
105
94
 
106
 
 
107
95
def dir_create(filename, conflict_handler, reverse):
108
96
    """Creates the directory, or deletes it if reverse is true.  Intended to be
109
97
    used with ReplaceContents.
129
117
        try:
130
118
            os.rmdir(filename)
131
119
        except OSError, e:
132
 
            if e.errno != errno.ENOTEMPTY:
 
120
            if e.errno != 39:
133
121
                raise
134
122
            if conflict_handler.rmdir_non_empty(filename) == "skip":
135
123
                return
136
124
            os.rmdir(filename)
137
125
 
 
126
                
 
127
            
138
128
 
139
129
class SymlinkCreate(object):
140
130
    """Creates or deletes a symlink (for use with ReplaceContents)"""
146
136
        """
147
137
        self.target = contents
148
138
 
149
 
    def __repr__(self):
150
 
        return "SymlinkCreate(%s)" % self.target
151
 
 
152
139
    def __call__(self, filename, conflict_handler, reverse):
153
140
        """Creates or destroys the symlink.
154
141
 
236
223
 
237
224
                    
238
225
 
239
 
class TreeFileCreate(object):
240
 
    """Create or delete a file (for use with ReplaceContents)"""
241
 
    def __init__(self, tree, file_id):
242
 
        """Constructor
243
 
 
244
 
        :param contents: The contents of the file to write
245
 
        :type contents: str
246
 
        """
247
 
        self.tree = tree
248
 
        self.file_id = file_id
249
 
 
250
 
    def __repr__(self):
251
 
        return "TreeFileCreate(%s)" % self.file_id
252
 
 
253
 
    def __eq__(self, other):
254
 
        if not isinstance(other, TreeFileCreate):
255
 
            return False
256
 
        return self.tree.get_file_sha1(self.file_id) == \
257
 
            other.tree.get_file_sha1(other.file_id)
258
 
 
259
 
    def __ne__(self, other):
260
 
        return not (self == other)
261
 
 
262
 
    def write_file(self, filename):
263
 
        outfile = file(filename, "wb")
264
 
        for line in self.tree.get_file(self.file_id):
265
 
            outfile.write(line)
266
 
 
267
 
    def same_text(self, filename):
268
 
        in_file = file(filename, "rb")
269
 
        return sha_file(in_file) == self.tree.get_file_sha1(self.file_id)
270
 
 
271
 
    def __call__(self, filename, conflict_handler, reverse):
272
 
        """Create or delete a file
273
 
 
274
 
        :param filename: The name of the file to create
275
 
        :type filename: str
276
 
        :param reverse: Delete the file instead of creating it
277
 
        :type reverse: bool
278
 
        """
279
 
        if not reverse:
280
 
            try:
281
 
                self.write_file(filename)
282
 
            except IOError, e:
283
 
                if e.errno == errno.ENOENT:
284
 
                    if conflict_handler.missing_parent(filename)=="continue":
285
 
                        self.write_file(filename)
286
 
                else:
287
 
                    raise
288
 
 
289
 
        else:
290
 
            try:
291
 
                if not self.same_text(filename):
292
 
                    direction = conflict_handler.wrong_old_contents(filename,
293
 
                        self.tree.get_file(self.file_id).read())
294
 
                    if  direction != "continue":
295
 
                        return
296
 
                os.unlink(filename)
297
 
            except IOError, e:
298
 
                if e.errno != errno.ENOENT:
299
 
                    raise
300
 
                if conflict_handler.missing_for_rm(filename, undo) == "skip":
301
 
                    return
302
 
 
303
 
                    
304
 
 
305
226
def reversed(sequence):
306
227
    max = len(sequence) - 1
307
228
    for i in range(len(sequence)):
374
295
            if mode is not None:
375
296
                os.chmod(filename, mode)
376
297
 
377
 
    def is_creation(self):
378
 
        return self.new_contents is not None and self.old_contents is None
379
 
 
380
 
    def is_deletion(self):
381
 
        return self.old_contents is not None and self.new_contents is None
382
 
 
383
298
class ApplySequence(object):
384
299
    def __init__(self, changes=None):
385
300
        self.changes = []
411
326
 
412
327
 
413
328
class Diff3Merge(object):
414
 
    history_based = False
415
329
    def __init__(self, file_id, base, other):
416
330
        self.file_id = file_id
417
331
        self.base = base
418
332
        self.other = other
419
333
 
420
 
    def is_creation(self):
421
 
        return False
422
 
 
423
 
    def is_deletion(self):
424
 
        return False
425
 
 
426
334
    def __eq__(self, other):
427
335
        if not isinstance(other, Diff3Merge):
428
336
            return False
432
340
    def __ne__(self, other):
433
341
        return not (self == other)
434
342
 
435
 
    def dump_file(self, temp_dir, name, tree):
436
 
        out_path = os.path.join(temp_dir, name)
437
 
        out_file = file(out_path, "wb")
438
 
        in_file = tree.get_file(self.file_id)
439
 
        for line in in_file:
440
 
            out_file.write(line)
441
 
        return out_path
442
 
 
443
343
    def apply(self, filename, conflict_handler, reverse=False):
444
 
        temp_dir = mkdtemp(prefix="bzr-")
445
 
        try:
446
 
            new_file = filename+".new"
447
 
            base_file = self.dump_file(temp_dir, "base", self.base)
448
 
            other_file = self.dump_file(temp_dir, "other", self.other)
449
 
            if not reverse:
450
 
                base = base_file
451
 
                other = other_file
452
 
            else:
453
 
                base = other_file
454
 
                other = base_file
455
 
            status = patch.diff3(new_file, filename, base, other)
456
 
            if status == 0:
457
 
                os.chmod(new_file, os.stat(filename).st_mode)
458
 
                rename(new_file, filename)
459
 
                return
460
 
            else:
461
 
                assert(status == 1)
462
 
                def get_lines(filename):
463
 
                    my_file = file(filename, "rb")
464
 
                    lines = my_file.readlines()
465
 
                    my_file.close()
466
 
                    return lines
467
 
                base_lines = get_lines(base)
468
 
                other_lines = get_lines(other)
469
 
                conflict_handler.merge_conflict(new_file, filename, base_lines, 
470
 
                                                other_lines)
471
 
        finally:
472
 
            rmtree(temp_dir)
 
344
        new_file = filename+".new"
 
345
        base_file = self.base.readonly_path(self.file_id)
 
346
        other_file = self.other.readonly_path(self.file_id)
 
347
        if not reverse:
 
348
            base = base_file
 
349
            other = other_file
 
350
        else:
 
351
            base = other_file
 
352
            other = base_file
 
353
        status = patch.diff3(new_file, filename, base, other)
 
354
        if status == 0:
 
355
            os.chmod(new_file, os.stat(filename).st_mode)
 
356
            os.rename(new_file, filename)
 
357
            return
 
358
        else:
 
359
            assert(status == 1)
 
360
            def get_lines(filename):
 
361
                my_file = file(base, "rb")
 
362
                lines = my_file.readlines()
 
363
                my_file.close()
 
364
            base_lines = get_lines(base)
 
365
            other_lines = get_lines(other)
 
366
            conflict_handler.merge_conflict(new_file, filename, base_lines, 
 
367
                                            other_lines)
473
368
 
474
369
 
475
370
def CreateDir():
508
403
    """
509
404
    return ReplaceContents(FileCreate(contents), None)
510
405
 
511
 
def ReplaceFileContents(old_tree, new_tree, file_id):
 
406
def ReplaceFileContents(old_contents, new_contents):
512
407
    """Convenience fucntion to replace the contents of a file.
513
408
    
514
409
    :param old_contents: The contents of the file to replace 
518
413
    :return: A ReplaceContents that will replace the contents of a file a file 
519
414
    :rtype: `ReplaceContents`
520
415
    """
521
 
    return ReplaceContents(TreeFileCreate(old_tree, file_id), 
522
 
                           TreeFileCreate(new_tree, file_id))
 
416
    return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
523
417
 
524
418
def CreateSymlink(target):
525
419
    """Convenience fucntion to create a symlink.
688
582
        :param reverse: if true, the changeset is being applied in reverse
689
583
        :rtype: bool
690
584
        """
691
 
        return self.is_creation(not reverse)
 
585
        return ((self.new_parent is None and not reverse) or 
 
586
                (self.parent is None and reverse))
692
587
 
693
588
    def is_creation(self, reverse):
694
589
        """Return true if applying the entry would create a file/directory.
696
591
        :param reverse: if true, the changeset is being applied in reverse
697
592
        :rtype: bool
698
593
        """
699
 
        if self.contents_change is None:
700
 
            return False
701
 
        if reverse:
702
 
            return self.contents_change.is_deletion()
703
 
        else:
704
 
            return self.contents_change.is_creation()
 
594
        return ((self.parent is None and not reverse) or 
 
595
                (self.new_parent is None and reverse))
705
596
 
706
597
    def is_creation_or_deletion(self):
707
598
        """Return true if applying the entry would create or delete a 
709
600
 
710
601
        :rtype: bool
711
602
        """
712
 
        return self.is_creation(False) or self.is_deletion(False)
 
603
        return self.parent is None or self.new_parent is None
713
604
 
714
605
    def get_cset_path(self, mod=False):
715
606
        """Determine the path of the entry according to the changeset.
887
778
    :rtype: (List, List)
888
779
    """
889
780
    source_entries = [x for x in changeset.entries.itervalues() 
890
 
                      if x.needs_rename() or x.is_creation_or_deletion()]
 
781
                      if x.needs_rename()]
891
782
    # these are done from longest path to shortest, to avoid deleting a
892
783
    # parent before its children are deleted/renamed 
893
784
    def longest_to_shortest(entry):
934
825
            entry.apply(path, conflict_handler, reverse)
935
826
            temp_name[entry.id] = None
936
827
 
937
 
        elif entry.needs_rename():
 
828
        else:
938
829
            to_name = os.path.join(temp_dir, str(i))
939
830
            src_path = inventory.get(entry.id)
940
831
            if src_path is not None:
941
832
                src_path = os.path.join(dir, src_path)
942
833
                try:
943
 
                    rename(src_path, to_name)
 
834
                    os.rename(src_path, to_name)
944
835
                    temp_name[entry.id] = to_name
945
836
                except OSError, e:
946
837
                    if e.errno != errno.ENOENT:
947
838
                        raise
948
 
                    if conflict_handler.missing_for_rename(src_path, to_name) \
949
 
                        == "skip":
 
839
                    if conflict_handler.missing_for_rename(src_path) == "skip":
950
840
                        continue
951
841
 
952
842
    return temp_name
973
863
            continue
974
864
        new_path = os.path.join(dir, new_tree_path)
975
865
        old_path = changed_inventory.get(entry.id)
976
 
        if bzrlib.osutils.lexists(new_path):
 
866
        if os.path.exists(new_path):
977
867
            if conflict_handler.target_exists(entry, new_path, old_path) == \
978
868
                "skip":
979
869
                continue
980
870
        if entry.is_creation(reverse):
981
871
            entry.apply(new_path, conflict_handler, reverse)
982
872
            changed_inventory[entry.id] = new_tree_path
983
 
        elif entry.needs_rename():
 
873
        else:
984
874
            if old_path is None:
985
875
                continue
986
876
            try:
987
 
                rename(old_path, new_path)
 
877
                os.rename(old_path, new_path)
988
878
                changed_inventory[entry.id] = new_tree_path
989
879
            except OSError, e:
990
880
                raise Exception ("%s is missing" % new_path)
1025
915
        Exception.__init__(self, "Conflict applying changes to %s" % this_path)
1026
916
        self.this_path = this_path
1027
917
 
 
918
class MergePermissionConflict(Exception):
 
919
    def __init__(self, this_path, base_path, other_path):
 
920
        this_perms = os.stat(this_path).st_mode & 0755
 
921
        base_perms = os.stat(base_path).st_mode & 0755
 
922
        other_perms = os.stat(other_path).st_mode & 0755
 
923
        msg = """Conflicting permission for %s
 
924
this: %o
 
925
base: %o
 
926
other: %o
 
927
        """ % (this_path, this_perms, base_perms, other_perms)
 
928
        self.this_path = this_path
 
929
        self.base_path = base_path
 
930
        self.other_path = other_path
 
931
        Exception.__init__(self, msg)
 
932
 
1028
933
class WrongOldContents(Exception):
1029
934
    def __init__(self, filename):
1030
935
        msg = "Contents mismatch deleting %s" % filename
1031
936
        self.filename = filename
1032
937
        Exception.__init__(self, msg)
1033
938
 
1034
 
class WrongOldExecFlag(Exception):
1035
 
    def __init__(self, filename, old_exec_flag, new_exec_flag):
1036
 
        msg = "Executable flag missmatch on %s:\n" \
1037
 
        "Expected %s, got %s." % (filename, old_exec_flag, new_exec_flag)
 
939
class WrongOldPermissions(Exception):
 
940
    def __init__(self, filename, old_perms, new_perms):
 
941
        msg = "Permission missmatch on %s:\n" \
 
942
        "Expected 0%o, got 0%o." % (filename, old_perms, new_perms)
1038
943
        self.filename = filename
1039
944
        Exception.__init__(self, msg)
1040
945
 
1058
963
        Exception.__init__(self, msg)
1059
964
        self.filename = filename
1060
965
 
1061
 
class MissingForSetExec(Exception):
 
966
class MissingPermsFile(Exception):
1062
967
    def __init__(self, filename):
1063
968
        msg = "Attempt to change permissions on  %s, which does not exist" %\
1064
969
            filename
1073
978
 
1074
979
 
1075
980
class MissingForRename(Exception):
1076
 
    def __init__(self, filename, to_path):
1077
 
        msg = "Attempt to move missing path %s to %s" % (filename, to_path)
 
981
    def __init__(self, filename):
 
982
        msg = "Attempt to move missing path %s" % (filename)
1078
983
        Exception.__init__(self, msg)
1079
984
        self.filename = filename
1080
985
 
1083
988
        msg = "Conflicting contents for new file %s" % (filename)
1084
989
        Exception.__init__(self, msg)
1085
990
 
1086
 
class WeaveMergeConflict(Exception):
1087
 
    def __init__(self, filename):
1088
 
        msg = "Conflicting contents for file %s" % (filename)
1089
 
        Exception.__init__(self, msg)
1090
 
 
1091
 
class ThreewayContentsConflict(Exception):
1092
 
    def __init__(self, filename):
1093
 
        msg = "Conflicting contents for file %s" % (filename)
1094
 
        Exception.__init__(self, msg)
1095
 
 
1096
991
 
1097
992
class MissingForMerge(Exception):
1098
993
    def __init__(self, filename):
1108
1003
    descend from this class if they have a better way to handle some or
1109
1004
    all types of conflict.
1110
1005
    """
 
1006
    def __init__(self, dir):
 
1007
        self.dir = dir
 
1008
    
1111
1009
    def missing_parent(self, pathname):
1112
1010
        parent = os.path.dirname(pathname)
1113
1011
        raise Exception("Parent directory missing for %s" % pathname)
1131
1029
        os.unlink(new_file)
1132
1030
        raise MergeConflict(this_path)
1133
1031
 
 
1032
    def permission_conflict(self, this_path, base_path, other_path):
 
1033
        raise MergePermissionConflict(this_path, base_path, other_path)
 
1034
 
1134
1035
    def wrong_old_contents(self, filename, expected_contents):
1135
1036
        raise WrongOldContents(filename)
1136
1037
 
1137
1038
    def rem_contents_conflict(self, filename, this_contents, base_contents):
1138
1039
        raise RemoveContentsConflict(filename)
1139
1040
 
1140
 
    def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
1141
 
        raise WrongOldExecFlag(filename, old_exec_flag, new_exec_flag)
 
1041
    def wrong_old_perms(self, filename, old_perms, new_perms):
 
1042
        raise WrongOldPermissions(filename, old_perms, new_perms)
1142
1043
 
1143
1044
    def rmdir_non_empty(self, filename):
1144
1045
        raise DeletingNonEmptyDirectory(filename)
1149
1050
    def patch_target_missing(self, filename, contents):
1150
1051
        raise PatchTargetMissing(filename)
1151
1052
 
1152
 
    def missing_for_exec_flag(self, filename):
1153
 
        raise MissingForExecFlag(filename)
 
1053
    def missing_for_chmod(self, filename):
 
1054
        raise MissingPermsFile(filename)
1154
1055
 
1155
1056
    def missing_for_rm(self, filename, change):
1156
1057
        raise MissingForRm(filename)
1157
1058
 
1158
 
    def missing_for_rename(self, filename, to_path):
1159
 
        raise MissingForRename(filename, to_path)
 
1059
    def missing_for_rename(self, filename):
 
1060
        raise MissingForRename(filename)
1160
1061
 
1161
1062
    def missing_for_merge(self, file_id, other_path):
1162
1063
        raise MissingForMerge(other_path)
1164
1065
    def new_contents_conflict(self, filename, other_contents):
1165
1066
        raise NewContentsConflict(filename)
1166
1067
 
1167
 
    def weave_merge_conflict(self, filename, weave, other_i, out_file):
1168
 
        raise WeaveMergeConflict(filename)
1169
 
 
1170
 
    def threeway_contents_conflict(self, filename, this_contents,
1171
 
                                   base_contents, other_contents):
1172
 
        raise ThreewayContentsConflict(filename)
1173
 
 
1174
 
    def finalize(self):
 
1068
    def finalize():
1175
1069
        pass
1176
1070
 
1177
1071
def apply_changeset(changeset, inventory, dir, conflict_handler=None, 
1190
1084
    :rtype: Dictionary
1191
1085
    """
1192
1086
    if conflict_handler is None:
1193
 
        conflict_handler = ExceptionConflictHandler()
 
1087
        conflict_handler = ExceptionConflictHandler(dir)
1194
1088
    temp_dir = os.path.join(dir, "bzr-tree-change")
1195
1089
    try:
1196
1090
        os.mkdir(temp_dir)
1207
1101
    
1208
1102
    #apply changes that don't affect filenames
1209
1103
    for entry in changeset.entries.itervalues():
1210
 
        if not entry.is_creation_or_deletion() and not entry.is_boring():
 
1104
        if not entry.is_creation_or_deletion():
1211
1105
            path = os.path.join(dir, inventory[entry.id])
1212
1106
            entry.apply(path, conflict_handler, reverse)
1213
1107
 
1232
1126
    r_inventory = {}
1233
1127
    for entry in tree.source_inventory().itervalues():
1234
1128
        inventory[entry.id] = entry.path
1235
 
    new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
 
1129
    new_inventory = apply_changeset(cset, r_inventory, tree.root,
1236
1130
                                    reverse=reverse)
1237
1131
    new_entries, remove_entries = \
1238
1132
        get_inventory_change(inventory, new_inventory, cset, reverse)
1373
1267
        return new_meta
1374
1268
    elif new_meta is None:
1375
1269
        return old_meta
1376
 
    elif (isinstance(old_meta, ChangeExecFlag) and
1377
 
          isinstance(new_meta, ChangeExecFlag)):
1378
 
        return ChangeExecFlag(old_meta.old_exec_flag, new_meta.new_exec_flag)
 
1270
    elif isinstance(old_meta, ChangeUnixPermissions) and \
 
1271
        isinstance(new_meta, ChangeUnixPermissions):
 
1272
        return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
1379
1273
    else:
1380
1274
        return ApplySequence(old_meta, new_meta)
1381
1275
 
1386
1280
            return False
1387
1281
    return True
1388
1282
 
1389
 
class UnsupportedFiletype(Exception):
1390
 
    def __init__(self, kind, full_path):
1391
 
        msg = "The file \"%s\" is a %s, which is not a supported filetype." \
1392
 
            % (full_path, kind)
 
1283
class UnsuppportedFiletype(Exception):
 
1284
    def __init__(self, full_path, stat_result):
 
1285
        msg = "The file \"%s\" is not a supported filetype." % full_path
1393
1286
        Exception.__init__(self, msg)
1394
1287
        self.full_path = full_path
1395
 
        self.kind = kind
 
1288
        self.stat_result = stat_result
1396
1289
 
1397
1290
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1398
1291
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1399
1292
 
1400
 
 
1401
1293
class ChangesetGenerator(object):
1402
1294
    def __init__(self, tree_a, tree_b, interesting_ids=None):
1403
1295
        object.__init__(self)
1439
1331
    def get_entry(self, file_id, tree):
1440
1332
        if not tree.has_or_had_id(file_id):
1441
1333
            return None
1442
 
        return tree.inventory[file_id]
 
1334
        return tree.tree.inventory[file_id]
1443
1335
 
1444
1336
    def get_entry_parent(self, entry):
1445
1337
        if entry is None:
1495
1387
 
1496
1388
        if cs_entry is None:
1497
1389
            return None
1498
 
 
1499
 
        cs_entry.metadata_change = self.make_exec_flag_change(id)
1500
 
 
1501
1390
        if id in self.tree_a and id in self.tree_b:
1502
1391
            a_sha1 = self.tree_a.get_file_sha1(id)
1503
1392
            b_sha1 = self.tree_b.get_file_sha1(id)
1504
1393
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1505
1394
                return cs_entry
1506
1395
 
1507
 
        cs_entry.contents_change = self.make_contents_change(id)
 
1396
        full_path_a = self.tree_a.readonly_path(id)
 
1397
        full_path_b = self.tree_b.readonly_path(id)
 
1398
        stat_a = self.lstat(full_path_a)
 
1399
        stat_b = self.lstat(full_path_b)
 
1400
        
 
1401
        cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
 
1402
        cs_entry.contents_change = self.make_contents_change(full_path_a,
 
1403
                                                             stat_a, 
 
1404
                                                             full_path_b, 
 
1405
                                                             stat_b)
1508
1406
        return cs_entry
1509
1407
 
1510
 
    def make_exec_flag_change(self, file_id):
1511
 
        exec_flag_a = exec_flag_b = None
1512
 
        if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
1513
 
            exec_flag_a = self.tree_a.is_executable(file_id)
1514
 
 
1515
 
        if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
1516
 
            exec_flag_b = self.tree_b.is_executable(file_id)
1517
 
 
1518
 
        if exec_flag_a == exec_flag_b:
1519
 
            return None
1520
 
        return ChangeExecFlag(exec_flag_a, exec_flag_b)
1521
 
 
1522
 
    def make_contents_change(self, file_id):
1523
 
        a_contents = get_contents(self.tree_a, file_id)
1524
 
        b_contents = get_contents(self.tree_b, file_id)
 
1408
    def make_mode_change(self, stat_a, stat_b):
 
1409
        mode_a = None
 
1410
        if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
 
1411
            mode_a = stat_a.st_mode & 0777
 
1412
        mode_b = None
 
1413
        if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
 
1414
            mode_b = stat_b.st_mode & 0777
 
1415
        if mode_a == mode_b:
 
1416
            return None
 
1417
        return ChangeUnixPermissions(mode_a, mode_b)
 
1418
 
 
1419
    def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
 
1420
        if stat_a is None and stat_b is None:
 
1421
            return None
 
1422
        if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
 
1423
            stat.S_ISDIR(stat_b.st_mode):
 
1424
            return None
 
1425
        if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
 
1426
            stat.S_ISREG(stat_b.st_mode):
 
1427
            if stat_a.st_ino == stat_b.st_ino and \
 
1428
                stat_a.st_dev == stat_b.st_dev:
 
1429
                return None
 
1430
 
 
1431
        a_contents = self.get_contents(stat_a, full_path_a)
 
1432
        b_contents = self.get_contents(stat_b, full_path_b)
1525
1433
        if a_contents == b_contents:
1526
1434
            return None
1527
1435
        return ReplaceContents(a_contents, b_contents)
1528
1436
 
 
1437
    def get_contents(self, stat_result, full_path):
 
1438
        if stat_result is None:
 
1439
            return None
 
1440
        elif stat.S_ISREG(stat_result.st_mode):
 
1441
            return FileCreate(file(full_path, "rb").read())
 
1442
        elif stat.S_ISDIR(stat_result.st_mode):
 
1443
            return dir_create
 
1444
        elif stat.S_ISLNK(stat_result.st_mode):
 
1445
            return SymlinkCreate(os.readlink(full_path))
 
1446
        else:
 
1447
            raise UnsupportedFiletype(full_path, stat_result)
1529
1448
 
1530
 
def get_contents(tree, file_id):
1531
 
    """Return the appropriate contents to create a copy of file_id from tree"""
1532
 
    if file_id not in tree:
1533
 
        return None
1534
 
    kind = tree.kind(file_id)
1535
 
    if kind == "file":
1536
 
        return TreeFileCreate(tree, file_id)
1537
 
    elif kind in ("directory", "root_directory"):
1538
 
        return dir_create
1539
 
    elif kind == "symlink":
1540
 
        return SymlinkCreate(tree.get_symlink_target(file_id))
1541
 
    else:
1542
 
        raise UnsupportedFiletype(kind, tree.id2path(file_id))
 
1449
    def lstat(self, full_path):
 
1450
        stat_result = None
 
1451
        if full_path is not None:
 
1452
            try:
 
1453
                stat_result = os.lstat(full_path)
 
1454
            except OSError, e:
 
1455
                if e.errno != errno.ENOENT:
 
1456
                    raise
 
1457
        return stat_result
1543
1458
 
1544
1459
 
1545
1460
def full_path(entry, tree):
1546
 
    return os.path.join(tree.basedir, entry.path)
 
1461
    return os.path.join(tree.root, entry.path)
1547
1462
 
1548
1463
def new_delete_entry(entry, tree, inventory, delete):
1549
1464
    if entry.path == "":