← 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-11-28 08:03:42 UTC
  • mto: (1185.33.61 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 1518.
  • Revision ID: mbp@sourcefrog.net-20051128080342-b7db3190dca90484
[broken] start converting basic_io to more rfc822-like format

Suggestions from mailing list:
 
  no double quotes
  no cute right-alignment
  no escaping
  just indent continuation lines

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
 
 
22
 
# XXX: mbp: I'm not totally convinced that we should handle conflicts
23
 
# as part of changeset application, rather than only in the merge
24
 
# operation.
25
 
 
26
 
"""Represent and apply a changeset
27
 
 
28
 
Conflicts in applying a changeset are represented as exceptions.
29
 
"""
 
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
30
36
 
31
37
__docformat__ = "restructuredtext"
32
38
 
42
48
        newdict[value] = key
43
49
    return newdict
44
50
 
45
 
 
46
51
       
47
 
class ChangeUnixPermissions(object):
 
52
class ChangeExecFlag(object):
48
53
    """This is two-way change, suitable for file modification, creation,
49
54
    deletion"""
50
 
    def __init__(self, old_mode, new_mode):
51
 
        self.old_mode = old_mode
52
 
        self.new_mode = new_mode
 
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
53
58
 
54
59
    def apply(self, filename, conflict_handler, reverse=False):
55
60
        if not reverse:
56
 
            from_mode = self.old_mode
57
 
            to_mode = self.new_mode
 
61
            from_exec_flag = self.old_exec_flag
 
62
            to_exec_flag = self.new_exec_flag
58
63
        else:
59
 
            from_mode = self.new_mode
60
 
            to_mode = self.old_mode
 
64
            from_exec_flag = self.new_exec_flag
 
65
            to_exec_flag = self.old_exec_flag
61
66
        try:
62
 
            current_mode = os.stat(filename).st_mode &0777
 
67
            current_exec_flag = bool(os.stat(filename).st_mode & 0111)
63
68
        except OSError, e:
64
69
            if e.errno == errno.ENOENT:
65
 
                if conflict_handler.missing_for_chmod(filename) == "skip":
 
70
                if conflict_handler.missing_for_exec_flag(filename) == "skip":
66
71
                    return
67
72
                else:
68
 
                    current_mode = from_mode
 
73
                    current_exec_flag = from_exec_flag
69
74
 
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":
 
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":
73
78
                return
74
79
 
75
 
        if to_mode is not None:
 
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
76
93
            try:
77
94
                os.chmod(filename, to_mode)
78
95
            except IOError, e:
79
96
                if e.errno == errno.ENOENT:
80
 
                    conflict_handler.missing_for_chmod(filename)
 
97
                    conflict_handler.missing_for_exec_flag(filename)
81
98
 
82
99
    def __eq__(self, other):
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
 
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)
91
103
 
92
104
    def __ne__(self, other):
93
105
        return not (self == other)
94
106
 
 
107
 
95
108
def dir_create(filename, conflict_handler, reverse):
96
109
    """Creates the directory, or deletes it if reverse is true.  Intended to be
97
110
    used with ReplaceContents.
117
130
        try:
118
131
            os.rmdir(filename)
119
132
        except OSError, e:
120
 
            if e.errno != 39:
 
133
            if e.errno != errno.ENOTEMPTY:
121
134
                raise
122
135
            if conflict_handler.rmdir_non_empty(filename) == "skip":
123
136
                return
124
137
            os.rmdir(filename)
125
138
 
126
 
                
127
 
            
128
139
 
129
140
class SymlinkCreate(object):
130
141
    """Creates or deletes a symlink (for use with ReplaceContents)"""
136
147
        """
137
148
        self.target = contents
138
149
 
 
150
    def __repr__(self):
 
151
        return "SymlinkCreate(%s)" % self.target
 
152
 
139
153
    def __call__(self, filename, conflict_handler, reverse):
140
154
        """Creates or destroys the symlink.
141
155
 
223
237
 
224
238
                    
225
239
 
 
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
 
226
306
def reversed(sequence):
227
307
    max = len(sequence) - 1
228
308
    for i in range(len(sequence)):
295
375
            if mode is not None:
296
376
                os.chmod(filename, mode)
297
377
 
 
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
 
298
384
class ApplySequence(object):
299
385
    def __init__(self, changes=None):
300
386
        self.changes = []
326
412
 
327
413
 
328
414
class Diff3Merge(object):
 
415
    history_based = False
329
416
    def __init__(self, file_id, base, other):
330
417
        self.file_id = file_id
331
418
        self.base = base
332
419
        self.other = other
333
420
 
 
421
    def is_creation(self):
 
422
        return False
 
423
 
 
424
    def is_deletion(self):
 
425
        return False
 
426
 
334
427
    def __eq__(self, other):
335
428
        if not isinstance(other, Diff3Merge):
336
429
            return False
340
433
    def __ne__(self, other):
341
434
        return not (self == other)
342
435
 
 
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
 
343
444
    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
 
            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)
 
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)
368
475
 
369
476
 
370
477
def CreateDir():
403
510
    """
404
511
    return ReplaceContents(FileCreate(contents), None)
405
512
 
406
 
def ReplaceFileContents(old_contents, new_contents):
 
513
def ReplaceFileContents(old_tree, new_tree, file_id):
407
514
    """Convenience fucntion to replace the contents of a file.
408
515
    
409
516
    :param old_contents: The contents of the file to replace 
413
520
    :return: A ReplaceContents that will replace the contents of a file a file 
414
521
    :rtype: `ReplaceContents`
415
522
    """
416
 
    return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
 
523
    return ReplaceContents(TreeFileCreate(old_tree, file_id), 
 
524
                           TreeFileCreate(new_tree, file_id))
417
525
 
418
526
def CreateSymlink(target):
419
527
    """Convenience fucntion to create a symlink.
525
633
        if self.id  == self.parent:
526
634
            raise ParentIDIsSelf(self)
527
635
 
528
 
    def __str__(self):
 
636
    def __repr__(self):
529
637
        return "ChangesetEntry(%s)" % self.id
530
638
 
 
639
    __str__ = __repr__
 
640
 
531
641
    def __get_dir(self):
532
642
        if self.path is None:
533
643
            return None
582
692
        :param reverse: if true, the changeset is being applied in reverse
583
693
        :rtype: bool
584
694
        """
585
 
        return ((self.new_parent is None and not reverse) or 
586
 
                (self.parent is None and reverse))
 
695
        return self.is_creation(not reverse)
587
696
 
588
697
    def is_creation(self, reverse):
589
698
        """Return true if applying the entry would create a file/directory.
591
700
        :param reverse: if true, the changeset is being applied in reverse
592
701
        :rtype: bool
593
702
        """
594
 
        return ((self.parent is None and not reverse) or 
595
 
                (self.new_parent is None and reverse))
 
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()
596
709
 
597
710
    def is_creation_or_deletion(self):
598
711
        """Return true if applying the entry would create or delete a 
600
713
 
601
714
        :rtype: bool
602
715
        """
603
 
        return self.parent is None or self.new_parent is None
 
716
        return self.is_creation(False) or self.is_deletion(False)
604
717
 
605
718
    def get_cset_path(self, mod=False):
606
719
        """Determine the path of the entry according to the changeset.
639
752
        """
640
753
        orig_path = self.get_cset_path(False)
641
754
        mod_path = self.get_cset_path(True)
642
 
        if orig_path is not None:
 
755
        if orig_path and orig_path.startswith('./'):
643
756
            orig_path = orig_path[2:]
644
 
        if mod_path is not None:
 
757
        if mod_path and mod_path.startswith('./'):
645
758
            mod_path = mod_path[2:]
646
759
        if orig_path == mod_path:
647
760
            return orig_path
663
776
        :type reverse: bool
664
777
        :rtype: str
665
778
        """
666
 
        mutter("Finding new path for %s" % self.summarize_name())
 
779
        mutter("Finding new path for %s", self.summarize_name())
667
780
        if reverse:
668
781
            parent = self.parent
669
782
            to_dir = self.dir
685
798
                raise SourceRootHasName(self, to_name)
686
799
            else:
687
800
                return '.'
688
 
        if from_dir == to_dir:
 
801
        parent_entry = changeset.entries.get(parent)
 
802
        if parent_entry is None:
689
803
            dir = os.path.dirname(id_map[self.id])
690
804
        else:
691
 
            mutter("path, new_path: %r %r" % (self.path, self.new_path))
692
 
            parent_entry = changeset.entries[parent]
 
805
            mutter("path, new_path: %r %r", self.path, self.new_path)
693
806
            dir = parent_entry.get_new_path(id_map, changeset, reverse)
694
807
        if from_name == to_name:
695
808
            name = os.path.basename(id_map[self.id])
778
891
    :rtype: (List, List)
779
892
    """
780
893
    source_entries = [x for x in changeset.entries.itervalues() 
781
 
                      if x.needs_rename()]
 
894
                      if x.needs_rename() or x.is_creation_or_deletion()]
782
895
    # these are done from longest path to shortest, to avoid deleting a
783
896
    # parent before its children are deleted/renamed 
784
897
    def longest_to_shortest(entry):
825
938
            entry.apply(path, conflict_handler, reverse)
826
939
            temp_name[entry.id] = None
827
940
 
828
 
        else:
 
941
        elif entry.needs_rename():
 
942
            if entry.is_creation(reverse):
 
943
                continue
829
944
            to_name = os.path.join(temp_dir, str(i))
830
945
            src_path = inventory.get(entry.id)
831
946
            if src_path is not None:
832
947
                src_path = os.path.join(dir, src_path)
833
948
                try:
834
 
                    os.rename(src_path, to_name)
 
949
                    rename(src_path, to_name)
835
950
                    temp_name[entry.id] = to_name
836
951
                except OSError, e:
837
952
                    if e.errno != errno.ENOENT:
838
953
                        raise
839
 
                    if conflict_handler.missing_for_rename(src_path) == "skip":
 
954
                    if conflict_handler.missing_for_rename(src_path, to_name) \
 
955
                        == "skip":
840
956
                        continue
841
957
 
842
958
    return temp_name
863
979
            continue
864
980
        new_path = os.path.join(dir, new_tree_path)
865
981
        old_path = changed_inventory.get(entry.id)
866
 
        if os.path.exists(new_path):
 
982
        if bzrlib.osutils.lexists(new_path):
867
983
            if conflict_handler.target_exists(entry, new_path, old_path) == \
868
984
                "skip":
869
985
                continue
870
986
        if entry.is_creation(reverse):
871
987
            entry.apply(new_path, conflict_handler, reverse)
872
988
            changed_inventory[entry.id] = new_tree_path
873
 
        else:
 
989
        elif entry.needs_rename():
 
990
            if entry.is_deletion(reverse):
 
991
                continue
874
992
            if old_path is None:
875
993
                continue
876
994
            try:
877
 
                os.rename(old_path, new_path)
 
995
                mutter('rename %s to final name %s', old_path, new_path)
 
996
                rename(old_path, new_path)
878
997
                changed_inventory[entry.id] = new_tree_path
879
998
            except OSError, e:
880
 
                raise Exception ("%s is missing" % new_path)
 
999
                raise BzrCheckError('failed to rename %s to %s for changeset entry %s: %s'
 
1000
                        % (old_path, new_path, entry, e))
881
1001
 
882
1002
class TargetExists(Exception):
883
1003
    def __init__(self, entry, target):
915
1035
        Exception.__init__(self, "Conflict applying changes to %s" % this_path)
916
1036
        self.this_path = this_path
917
1037
 
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
1038
class WrongOldContents(Exception):
934
1039
    def __init__(self, filename):
935
1040
        msg = "Contents mismatch deleting %s" % filename
936
1041
        self.filename = filename
937
1042
        Exception.__init__(self, msg)
938
1043
 
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)
 
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)
943
1048
        self.filename = filename
944
1049
        Exception.__init__(self, msg)
945
1050
 
963
1068
        Exception.__init__(self, msg)
964
1069
        self.filename = filename
965
1070
 
966
 
class MissingPermsFile(Exception):
 
1071
class MissingForSetExec(Exception):
967
1072
    def __init__(self, filename):
968
1073
        msg = "Attempt to change permissions on  %s, which does not exist" %\
969
1074
            filename
978
1083
 
979
1084
 
980
1085
class MissingForRename(Exception):
981
 
    def __init__(self, filename):
982
 
        msg = "Attempt to move missing path %s" % (filename)
 
1086
    def __init__(self, filename, to_path):
 
1087
        msg = "Attempt to move missing path %s to %s" % (filename, to_path)
983
1088
        Exception.__init__(self, msg)
984
1089
        self.filename = filename
985
1090
 
988
1093
        msg = "Conflicting contents for new file %s" % (filename)
989
1094
        Exception.__init__(self, msg)
990
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
 
991
1106
 
992
1107
class MissingForMerge(Exception):
993
1108
    def __init__(self, filename):
1003
1118
    descend from this class if they have a better way to handle some or
1004
1119
    all types of conflict.
1005
1120
    """
1006
 
    def __init__(self, dir):
1007
 
        self.dir = dir
1008
 
    
1009
1121
    def missing_parent(self, pathname):
1010
1122
        parent = os.path.dirname(pathname)
1011
1123
        raise Exception("Parent directory missing for %s" % pathname)
1029
1141
        os.unlink(new_file)
1030
1142
        raise MergeConflict(this_path)
1031
1143
 
1032
 
    def permission_conflict(self, this_path, base_path, other_path):
1033
 
        raise MergePermissionConflict(this_path, base_path, other_path)
1034
 
 
1035
1144
    def wrong_old_contents(self, filename, expected_contents):
1036
1145
        raise WrongOldContents(filename)
1037
1146
 
1038
1147
    def rem_contents_conflict(self, filename, this_contents, base_contents):
1039
1148
        raise RemoveContentsConflict(filename)
1040
1149
 
1041
 
    def wrong_old_perms(self, filename, old_perms, new_perms):
1042
 
        raise WrongOldPermissions(filename, old_perms, new_perms)
 
1150
    def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
 
1151
        raise WrongOldExecFlag(filename, old_exec_flag, new_exec_flag)
1043
1152
 
1044
1153
    def rmdir_non_empty(self, filename):
1045
1154
        raise DeletingNonEmptyDirectory(filename)
1050
1159
    def patch_target_missing(self, filename, contents):
1051
1160
        raise PatchTargetMissing(filename)
1052
1161
 
1053
 
    def missing_for_chmod(self, filename):
1054
 
        raise MissingPermsFile(filename)
 
1162
    def missing_for_exec_flag(self, filename):
 
1163
        raise MissingForExecFlag(filename)
1055
1164
 
1056
1165
    def missing_for_rm(self, filename, change):
1057
1166
        raise MissingForRm(filename)
1058
1167
 
1059
 
    def missing_for_rename(self, filename):
1060
 
        raise MissingForRename(filename)
 
1168
    def missing_for_rename(self, filename, to_path):
 
1169
        raise MissingForRename(filename, to_path)
1061
1170
 
1062
1171
    def missing_for_merge(self, file_id, other_path):
1063
1172
        raise MissingForMerge(other_path)
1065
1174
    def new_contents_conflict(self, filename, other_contents):
1066
1175
        raise NewContentsConflict(filename)
1067
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
 
1068
1184
    def finalize(self):
1069
1185
        pass
1070
1186
 
1084
1200
    :rtype: Dictionary
1085
1201
    """
1086
1202
    if conflict_handler is None:
1087
 
        conflict_handler = ExceptionConflictHandler(dir)
 
1203
        conflict_handler = ExceptionConflictHandler()
1088
1204
    temp_dir = os.path.join(dir, "bzr-tree-change")
1089
1205
    try:
1090
1206
        os.mkdir(temp_dir)
1101
1217
    
1102
1218
    #apply changes that don't affect filenames
1103
1219
    for entry in changeset.entries.itervalues():
1104
 
        if not entry.is_creation_or_deletion():
 
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
1105
1225
            path = os.path.join(dir, inventory[entry.id])
1106
1226
            entry.apply(path, conflict_handler, reverse)
1107
1227
 
1126
1246
    r_inventory = {}
1127
1247
    for entry in tree.source_inventory().itervalues():
1128
1248
        inventory[entry.id] = entry.path
1129
 
    new_inventory = apply_changeset(cset, r_inventory, tree.root,
 
1249
    new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
1130
1250
                                    reverse=reverse)
1131
1251
    new_entries, remove_entries = \
1132
1252
        get_inventory_change(inventory, new_inventory, cset, reverse)
1267
1387
        return new_meta
1268
1388
    elif new_meta is None:
1269
1389
        return old_meta
1270
 
    elif isinstance(old_meta, ChangeUnixPermissions) and \
1271
 
        isinstance(new_meta, ChangeUnixPermissions):
1272
 
        return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
 
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)
1273
1393
    else:
1274
1394
        return ApplySequence(old_meta, new_meta)
1275
1395
 
1280
1400
            return False
1281
1401
    return True
1282
1402
 
1283
 
class UnsuppportedFiletype(Exception):
1284
 
    def __init__(self, full_path, stat_result):
1285
 
        msg = "The file \"%s\" is not a supported filetype." % full_path
 
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)
1286
1407
        Exception.__init__(self, msg)
1287
1408
        self.full_path = full_path
1288
 
        self.stat_result = stat_result
 
1409
        self.kind = kind
1289
1410
 
1290
1411
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1291
1412
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1292
1413
 
 
1414
 
1293
1415
class ChangesetGenerator(object):
1294
1416
    def __init__(self, tree_a, tree_b, interesting_ids=None):
1295
1417
        object.__init__(self)
1331
1453
    def get_entry(self, file_id, tree):
1332
1454
        if not tree.has_or_had_id(file_id):
1333
1455
            return None
1334
 
        return tree.tree.inventory[file_id]
 
1456
        return tree.inventory[file_id]
1335
1457
 
1336
1458
    def get_entry_parent(self, entry):
1337
1459
        if entry is None:
1387
1509
 
1388
1510
        if cs_entry is None:
1389
1511
            return None
 
1512
 
 
1513
        cs_entry.metadata_change = self.make_exec_flag_change(id)
 
1514
 
1390
1515
        if id in self.tree_a and id in self.tree_b:
1391
1516
            a_sha1 = self.tree_a.get_file_sha1(id)
1392
1517
            b_sha1 = self.tree_b.get_file_sha1(id)
1393
1518
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1394
1519
                return cs_entry
1395
1520
 
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)
 
1521
        cs_entry.contents_change = self.make_contents_change(id)
1406
1522
        return cs_entry
1407
1523
 
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)
 
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)
1433
1539
        if a_contents == b_contents:
1434
1540
            return None
1435
1541
        return ReplaceContents(a_contents, b_contents)
1436
1542
 
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)
1448
1543
 
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
 
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))
1458
1557
 
1459
1558
 
1460
1559
def full_path(entry, tree):
1461
 
    return os.path.join(tree.root, entry.path)
 
1560
    return os.path.join(tree.basedir, entry.path)
1462
1561
 
1463
1562
def new_delete_entry(entry, tree, inventory, delete):
1464
1563
    if entry.path == "":