← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/changeset.py

Exclude more files from dumb-rsync upload

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
16
25
import os.path
17
26
import errno
18
 
import patch
19
27
import stat
20
 
from bzrlib.trace import mutter
21
 
from bzrlib.osutils import rename
 
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
22
34
import bzrlib
23
35
 
24
 
# XXX: mbp: I'm not totally convinced that we should handle conflicts
25
 
# as part of changeset application, rather than only in the merge
26
 
# operation.
27
 
 
28
 
"""Represent and apply a changeset
29
 
 
30
 
Conflicts in applying a changeset are represented as exceptions.
31
 
"""
32
 
 
33
36
__docformat__ = "restructuredtext"
34
37
 
35
38
NULL_ID = "!NULL"
45
48
    return newdict
46
49
 
47
50
       
48
 
class ChangeUnixPermissions(object):
 
51
class ChangeExecFlag(object):
49
52
    """This is two-way change, suitable for file modification, creation,
50
53
    deletion"""
51
 
    def __init__(self, old_mode, new_mode):
52
 
        self.old_mode = old_mode
53
 
        self.new_mode = new_mode
 
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
54
57
 
55
58
    def apply(self, filename, conflict_handler, reverse=False):
56
59
        if not reverse:
57
 
            from_mode = self.old_mode
58
 
            to_mode = self.new_mode
 
60
            from_exec_flag = self.old_exec_flag
 
61
            to_exec_flag = self.new_exec_flag
59
62
        else:
60
 
            from_mode = self.new_mode
61
 
            to_mode = self.old_mode
 
63
            from_exec_flag = self.new_exec_flag
 
64
            to_exec_flag = self.old_exec_flag
62
65
        try:
63
 
            current_mode = os.stat(filename).st_mode &0777
 
66
            current_exec_flag = bool(os.stat(filename).st_mode & 0111)
64
67
        except OSError, e:
65
68
            if e.errno == errno.ENOENT:
66
 
                if conflict_handler.missing_for_chmod(filename) == "skip":
 
69
                if conflict_handler.missing_for_exec_flag(filename) == "skip":
67
70
                    return
68
71
                else:
69
 
                    current_mode = from_mode
 
72
                    current_exec_flag = from_exec_flag
70
73
 
71
 
        if from_mode is not None and current_mode != from_mode:
72
 
            if conflict_handler.wrong_old_perms(filename, from_mode, 
73
 
                                                current_mode) != "continue":
 
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":
74
77
                return
75
78
 
76
 
        if to_mode is not None:
 
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
77
92
            try:
78
93
                os.chmod(filename, to_mode)
79
94
            except IOError, e:
80
95
                if e.errno == errno.ENOENT:
81
 
                    conflict_handler.missing_for_chmod(filename)
 
96
                    conflict_handler.missing_for_exec_flag(filename)
82
97
 
83
98
    def __eq__(self, other):
84
 
        if not isinstance(other, ChangeUnixPermissions):
85
 
            return False
86
 
        elif self.old_mode != other.old_mode:
87
 
            return False
88
 
        elif self.new_mode != other.new_mode:
89
 
            return False
90
 
        else:
91
 
            return True
 
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)
92
102
 
93
103
    def __ne__(self, other):
94
104
        return not (self == other)
136
146
        """
137
147
        self.target = contents
138
148
 
 
149
    def __repr__(self):
 
150
        return "SymlinkCreate(%s)" % self.target
 
151
 
139
152
    def __call__(self, filename, conflict_handler, reverse):
140
153
        """Creates or destroys the symlink.
141
154
 
223
236
 
224
237
                    
225
238
 
 
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
 
226
305
def reversed(sequence):
227
306
    max = len(sequence) - 1
228
307
    for i in range(len(sequence)):
295
374
            if mode is not None:
296
375
                os.chmod(filename, mode)
297
376
 
 
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
 
298
383
class ApplySequence(object):
299
384
    def __init__(self, changes=None):
300
385
        self.changes = []
326
411
 
327
412
 
328
413
class Diff3Merge(object):
 
414
    history_based = False
329
415
    def __init__(self, file_id, base, other):
330
416
        self.file_id = file_id
331
417
        self.base = base
332
418
        self.other = other
333
419
 
 
420
    def is_creation(self):
 
421
        return False
 
422
 
 
423
    def is_deletion(self):
 
424
        return False
 
425
 
334
426
    def __eq__(self, other):
335
427
        if not isinstance(other, Diff3Merge):
336
428
            return False
340
432
    def __ne__(self, other):
341
433
        return not (self == other)
342
434
 
 
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
 
343
443
    def apply(self, filename, conflict_handler, reverse=False):
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
 
            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)
 
444
        import bzrlib.patch
 
445
        temp_dir = mkdtemp(prefix="bzr-")
 
446
        try:
 
447
            new_file = filename+".new"
 
448
            base_file = self.dump_file(temp_dir, "base", self.base)
 
449
            other_file = self.dump_file(temp_dir, "other", self.other)
 
450
            if not reverse:
 
451
                base = base_file
 
452
                other = other_file
 
453
            else:
 
454
                base = other_file
 
455
                other = base_file
 
456
            status = bzrlib.patch.diff3(new_file, filename, base, other)
 
457
            if status == 0:
 
458
                os.chmod(new_file, os.stat(filename).st_mode)
 
459
                rename(new_file, filename)
 
460
                return
 
461
            else:
 
462
                assert(status == 1)
 
463
                def get_lines(filename):
 
464
                    my_file = file(filename, "rb")
 
465
                    lines = my_file.readlines()
 
466
                    my_file.close()
 
467
                    return lines
 
468
                base_lines = get_lines(base)
 
469
                other_lines = get_lines(other)
 
470
                conflict_handler.merge_conflict(new_file, filename, base_lines, 
 
471
                                                other_lines)
 
472
        finally:
 
473
            rmtree(temp_dir)
368
474
 
369
475
 
370
476
def CreateDir():
403
509
    """
404
510
    return ReplaceContents(FileCreate(contents), None)
405
511
 
406
 
def ReplaceFileContents(old_contents, new_contents):
 
512
def ReplaceFileContents(old_tree, new_tree, file_id):
407
513
    """Convenience fucntion to replace the contents of a file.
408
514
    
409
515
    :param old_contents: The contents of the file to replace 
413
519
    :return: A ReplaceContents that will replace the contents of a file a file 
414
520
    :rtype: `ReplaceContents`
415
521
    """
416
 
    return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
 
522
    return ReplaceContents(TreeFileCreate(old_tree, file_id), 
 
523
                           TreeFileCreate(new_tree, file_id))
417
524
 
418
525
def CreateSymlink(target):
419
526
    """Convenience fucntion to create a symlink.
582
689
        :param reverse: if true, the changeset is being applied in reverse
583
690
        :rtype: bool
584
691
        """
585
 
        return ((self.new_parent is None and not reverse) or 
586
 
                (self.parent is None and reverse))
 
692
        return self.is_creation(not reverse)
587
693
 
588
694
    def is_creation(self, reverse):
589
695
        """Return true if applying the entry would create a file/directory.
591
697
        :param reverse: if true, the changeset is being applied in reverse
592
698
        :rtype: bool
593
699
        """
594
 
        return ((self.parent is None and not reverse) or 
595
 
                (self.new_parent is None and reverse))
 
700
        if self.contents_change is None:
 
701
            return False
 
702
        if reverse:
 
703
            return self.contents_change.is_deletion()
 
704
        else:
 
705
            return self.contents_change.is_creation()
596
706
 
597
707
    def is_creation_or_deletion(self):
598
708
        """Return true if applying the entry would create or delete a 
600
710
 
601
711
        :rtype: bool
602
712
        """
603
 
        return self.parent is None or self.new_parent is None
 
713
        return self.is_creation(False) or self.is_deletion(False)
604
714
 
605
715
    def get_cset_path(self, mod=False):
606
716
        """Determine the path of the entry according to the changeset.
663
773
        :type reverse: bool
664
774
        :rtype: str
665
775
        """
666
 
        mutter("Finding new path for %s" % self.summarize_name())
 
776
        mutter("Finding new path for %s", self.summarize_name())
667
777
        if reverse:
668
778
            parent = self.parent
669
779
            to_dir = self.dir
688
798
        if from_dir == to_dir:
689
799
            dir = os.path.dirname(id_map[self.id])
690
800
        else:
691
 
            mutter("path, new_path: %r %r" % (self.path, self.new_path))
 
801
            mutter("path, new_path: %r %r", self.path, self.new_path)
692
802
            parent_entry = changeset.entries[parent]
693
803
            dir = parent_entry.get_new_path(id_map, changeset, reverse)
694
804
        if from_name == to_name:
778
888
    :rtype: (List, List)
779
889
    """
780
890
    source_entries = [x for x in changeset.entries.itervalues() 
781
 
                      if x.needs_rename()]
 
891
                      if x.needs_rename() or x.is_creation_or_deletion()]
782
892
    # these are done from longest path to shortest, to avoid deleting a
783
893
    # parent before its children are deleted/renamed 
784
894
    def longest_to_shortest(entry):
825
935
            entry.apply(path, conflict_handler, reverse)
826
936
            temp_name[entry.id] = None
827
937
 
828
 
        else:
 
938
        elif entry.needs_rename():
829
939
            to_name = os.path.join(temp_dir, str(i))
830
940
            src_path = inventory.get(entry.id)
831
941
            if src_path is not None:
836
946
                except OSError, e:
837
947
                    if e.errno != errno.ENOENT:
838
948
                        raise
839
 
                    if conflict_handler.missing_for_rename(src_path) == "skip":
 
949
                    if conflict_handler.missing_for_rename(src_path, to_name) \
 
950
                        == "skip":
840
951
                        continue
841
952
 
842
953
    return temp_name
870
981
        if entry.is_creation(reverse):
871
982
            entry.apply(new_path, conflict_handler, reverse)
872
983
            changed_inventory[entry.id] = new_tree_path
873
 
        else:
 
984
        elif entry.needs_rename():
874
985
            if old_path is None:
875
986
                continue
876
987
            try:
915
1026
        Exception.__init__(self, "Conflict applying changes to %s" % this_path)
916
1027
        self.this_path = this_path
917
1028
 
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
 
 
933
1029
class WrongOldContents(Exception):
934
1030
    def __init__(self, filename):
935
1031
        msg = "Contents mismatch deleting %s" % filename
936
1032
        self.filename = filename
937
1033
        Exception.__init__(self, msg)
938
1034
 
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)
 
1035
class WrongOldExecFlag(Exception):
 
1036
    def __init__(self, filename, old_exec_flag, new_exec_flag):
 
1037
        msg = "Executable flag missmatch on %s:\n" \
 
1038
        "Expected %s, got %s." % (filename, old_exec_flag, new_exec_flag)
943
1039
        self.filename = filename
944
1040
        Exception.__init__(self, msg)
945
1041
 
963
1059
        Exception.__init__(self, msg)
964
1060
        self.filename = filename
965
1061
 
966
 
class MissingPermsFile(Exception):
 
1062
class MissingForSetExec(Exception):
967
1063
    def __init__(self, filename):
968
1064
        msg = "Attempt to change permissions on  %s, which does not exist" %\
969
1065
            filename
978
1074
 
979
1075
 
980
1076
class MissingForRename(Exception):
981
 
    def __init__(self, filename):
982
 
        msg = "Attempt to move missing path %s" % (filename)
 
1077
    def __init__(self, filename, to_path):
 
1078
        msg = "Attempt to move missing path %s to %s" % (filename, to_path)
983
1079
        Exception.__init__(self, msg)
984
1080
        self.filename = filename
985
1081
 
988
1084
        msg = "Conflicting contents for new file %s" % (filename)
989
1085
        Exception.__init__(self, msg)
990
1086
 
 
1087
class WeaveMergeConflict(Exception):
 
1088
    def __init__(self, filename):
 
1089
        msg = "Conflicting contents for file %s" % (filename)
 
1090
        Exception.__init__(self, msg)
 
1091
 
 
1092
class ThreewayContentsConflict(Exception):
 
1093
    def __init__(self, filename):
 
1094
        msg = "Conflicting contents for file %s" % (filename)
 
1095
        Exception.__init__(self, msg)
 
1096
 
991
1097
 
992
1098
class MissingForMerge(Exception):
993
1099
    def __init__(self, filename):
1026
1132
        os.unlink(new_file)
1027
1133
        raise MergeConflict(this_path)
1028
1134
 
1029
 
    def permission_conflict(self, this_path, base_path, other_path):
1030
 
        raise MergePermissionConflict(this_path, base_path, other_path)
1031
 
 
1032
1135
    def wrong_old_contents(self, filename, expected_contents):
1033
1136
        raise WrongOldContents(filename)
1034
1137
 
1035
1138
    def rem_contents_conflict(self, filename, this_contents, base_contents):
1036
1139
        raise RemoveContentsConflict(filename)
1037
1140
 
1038
 
    def wrong_old_perms(self, filename, old_perms, new_perms):
1039
 
        raise WrongOldPermissions(filename, old_perms, new_perms)
 
1141
    def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
 
1142
        raise WrongOldExecFlag(filename, old_exec_flag, new_exec_flag)
1040
1143
 
1041
1144
    def rmdir_non_empty(self, filename):
1042
1145
        raise DeletingNonEmptyDirectory(filename)
1047
1150
    def patch_target_missing(self, filename, contents):
1048
1151
        raise PatchTargetMissing(filename)
1049
1152
 
1050
 
    def missing_for_chmod(self, filename):
1051
 
        raise MissingPermsFile(filename)
 
1153
    def missing_for_exec_flag(self, filename):
 
1154
        raise MissingForExecFlag(filename)
1052
1155
 
1053
1156
    def missing_for_rm(self, filename, change):
1054
1157
        raise MissingForRm(filename)
1055
1158
 
1056
 
    def missing_for_rename(self, filename):
1057
 
        raise MissingForRename(filename)
 
1159
    def missing_for_rename(self, filename, to_path):
 
1160
        raise MissingForRename(filename, to_path)
1058
1161
 
1059
1162
    def missing_for_merge(self, file_id, other_path):
1060
1163
        raise MissingForMerge(other_path)
1062
1165
    def new_contents_conflict(self, filename, other_contents):
1063
1166
        raise NewContentsConflict(filename)
1064
1167
 
 
1168
    def weave_merge_conflict(self, filename, weave, other_i, out_file):
 
1169
        raise WeaveMergeConflict(filename)
 
1170
 
 
1171
    def threeway_contents_conflict(self, filename, this_contents,
 
1172
                                   base_contents, other_contents):
 
1173
        raise ThreewayContentsConflict(filename)
 
1174
 
1065
1175
    def finalize(self):
1066
1176
        pass
1067
1177
 
1098
1208
    
1099
1209
    #apply changes that don't affect filenames
1100
1210
    for entry in changeset.entries.itervalues():
1101
 
        if not entry.is_creation_or_deletion():
 
1211
        if not entry.is_creation_or_deletion() and not entry.is_boring():
 
1212
            if entry.id not in inventory:
 
1213
                warning("entry {%s} no longer present, can't be updated",
 
1214
                        entry.id)
 
1215
                continue
1102
1216
            path = os.path.join(dir, inventory[entry.id])
1103
1217
            entry.apply(path, conflict_handler, reverse)
1104
1218
 
1123
1237
    r_inventory = {}
1124
1238
    for entry in tree.source_inventory().itervalues():
1125
1239
        inventory[entry.id] = entry.path
1126
 
    new_inventory = apply_changeset(cset, r_inventory, tree.root,
 
1240
    new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
1127
1241
                                    reverse=reverse)
1128
1242
    new_entries, remove_entries = \
1129
1243
        get_inventory_change(inventory, new_inventory, cset, reverse)
1264
1378
        return new_meta
1265
1379
    elif new_meta is None:
1266
1380
        return old_meta
1267
 
    elif isinstance(old_meta, ChangeUnixPermissions) and \
1268
 
        isinstance(new_meta, ChangeUnixPermissions):
1269
 
        return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
 
1381
    elif (isinstance(old_meta, ChangeExecFlag) and
 
1382
          isinstance(new_meta, ChangeExecFlag)):
 
1383
        return ChangeExecFlag(old_meta.old_exec_flag, new_meta.new_exec_flag)
1270
1384
    else:
1271
1385
        return ApplySequence(old_meta, new_meta)
1272
1386
 
1277
1391
            return False
1278
1392
    return True
1279
1393
 
1280
 
class UnsuppportedFiletype(Exception):
1281
 
    def __init__(self, full_path, stat_result):
1282
 
        msg = "The file \"%s\" is not a supported filetype." % full_path
 
1394
class UnsupportedFiletype(Exception):
 
1395
    def __init__(self, kind, full_path):
 
1396
        msg = "The file \"%s\" is a %s, which is not a supported filetype." \
 
1397
            % (full_path, kind)
1283
1398
        Exception.__init__(self, msg)
1284
1399
        self.full_path = full_path
1285
 
        self.stat_result = stat_result
 
1400
        self.kind = kind
1286
1401
 
1287
1402
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1288
1403
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1289
1404
 
 
1405
 
1290
1406
class ChangesetGenerator(object):
1291
1407
    def __init__(self, tree_a, tree_b, interesting_ids=None):
1292
1408
        object.__init__(self)
1328
1444
    def get_entry(self, file_id, tree):
1329
1445
        if not tree.has_or_had_id(file_id):
1330
1446
            return None
1331
 
        return tree.tree.inventory[file_id]
 
1447
        return tree.inventory[file_id]
1332
1448
 
1333
1449
    def get_entry_parent(self, entry):
1334
1450
        if entry is None:
1385
1501
        if cs_entry is None:
1386
1502
            return None
1387
1503
 
1388
 
        full_path_a = self.tree_a.readonly_path(id)
1389
 
        full_path_b = self.tree_b.readonly_path(id)
1390
 
        stat_a = self.lstat(full_path_a)
1391
 
        stat_b = self.lstat(full_path_b)
1392
 
 
1393
 
        cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
 
1504
        cs_entry.metadata_change = self.make_exec_flag_change(id)
1394
1505
 
1395
1506
        if id in self.tree_a and id in self.tree_b:
1396
1507
            a_sha1 = self.tree_a.get_file_sha1(id)
1398
1509
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1399
1510
                return cs_entry
1400
1511
 
1401
 
        cs_entry.contents_change = self.make_contents_change(full_path_a,
1402
 
                                                             stat_a, 
1403
 
                                                             full_path_b, 
1404
 
                                                             stat_b)
 
1512
        cs_entry.contents_change = self.make_contents_change(id)
1405
1513
        return cs_entry
1406
1514
 
1407
 
    def make_mode_change(self, stat_a, stat_b):
1408
 
        mode_a = None
1409
 
        if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
1410
 
            mode_a = stat_a.st_mode & 0777
1411
 
        mode_b = None
1412
 
        if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
1413
 
            mode_b = stat_b.st_mode & 0777
1414
 
        if mode_a == mode_b:
1415
 
            return None
1416
 
        return ChangeUnixPermissions(mode_a, mode_b)
1417
 
 
1418
 
    def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
1419
 
        if stat_a is None and stat_b is None:
1420
 
            return None
1421
 
        if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
1422
 
            stat.S_ISDIR(stat_b.st_mode):
1423
 
            return None
1424
 
        if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
1425
 
            stat.S_ISREG(stat_b.st_mode):
1426
 
            if stat_a.st_ino == stat_b.st_ino and \
1427
 
                stat_a.st_dev == stat_b.st_dev:
1428
 
                return None
1429
 
 
1430
 
        a_contents = self.get_contents(stat_a, full_path_a)
1431
 
        b_contents = self.get_contents(stat_b, full_path_b)
 
1515
    def make_exec_flag_change(self, file_id):
 
1516
        exec_flag_a = exec_flag_b = None
 
1517
        if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
 
1518
            exec_flag_a = self.tree_a.is_executable(file_id)
 
1519
 
 
1520
        if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
 
1521
            exec_flag_b = self.tree_b.is_executable(file_id)
 
1522
 
 
1523
        if exec_flag_a == exec_flag_b:
 
1524
            return None
 
1525
        return ChangeExecFlag(exec_flag_a, exec_flag_b)
 
1526
 
 
1527
    def make_contents_change(self, file_id):
 
1528
        a_contents = get_contents(self.tree_a, file_id)
 
1529
        b_contents = get_contents(self.tree_b, file_id)
1432
1530
        if a_contents == b_contents:
1433
1531
            return None
1434
1532
        return ReplaceContents(a_contents, b_contents)
1435
1533
 
1436
 
    def get_contents(self, stat_result, full_path):
1437
 
        if stat_result is None:
1438
 
            return None
1439
 
        elif stat.S_ISREG(stat_result.st_mode):
1440
 
            return FileCreate(file(full_path, "rb").read())
1441
 
        elif stat.S_ISDIR(stat_result.st_mode):
1442
 
            return dir_create
1443
 
        elif stat.S_ISLNK(stat_result.st_mode):
1444
 
            return SymlinkCreate(os.readlink(full_path))
1445
 
        else:
1446
 
            raise UnsupportedFiletype(full_path, stat_result)
1447
1534
 
1448
 
    def lstat(self, full_path):
1449
 
        stat_result = None
1450
 
        if full_path is not None:
1451
 
            try:
1452
 
                stat_result = os.lstat(full_path)
1453
 
            except OSError, e:
1454
 
                if e.errno != errno.ENOENT:
1455
 
                    raise
1456
 
        return stat_result
 
1535
def get_contents(tree, file_id):
 
1536
    """Return the appropriate contents to create a copy of file_id from tree"""
 
1537
    if file_id not in tree:
 
1538
        return None
 
1539
    kind = tree.kind(file_id)
 
1540
    if kind == "file":
 
1541
        return TreeFileCreate(tree, file_id)
 
1542
    elif kind in ("directory", "root_directory"):
 
1543
        return dir_create
 
1544
    elif kind == "symlink":
 
1545
        return SymlinkCreate(tree.get_symlink_target(file_id))
 
1546
    else:
 
1547
        raise UnsupportedFiletype(kind, tree.id2path(file_id))
1457
1548
 
1458
1549
 
1459
1550
def full_path(entry, tree):
1460
 
    return os.path.join(tree.root, entry.path)
 
1551
    return os.path.join(tree.basedir, entry.path)
1461
1552
 
1462
1553
def new_delete_entry(entry, tree, inventory, delete):
1463
1554
    if entry.path == "":