/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/changeset.py

Changing final merge message to All changes applied successfully, rather than 0 conflicts applied.

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
 
Represent and apply a changeset
23
 
"""
 
28
from tempfile import mkdtemp
 
29
from shutil import rmtree
 
30
from itertools import izip
 
31
 
 
32
from bzrlib.trace import mutter, warning
 
33
from bzrlib.osutils import rename, sha_file
 
34
import bzrlib
 
35
from bzrlib.errors import BzrCheckError
 
36
 
24
37
__docformat__ = "restructuredtext"
25
38
 
26
39
NULL_ID = "!NULL"
35
48
        newdict[value] = key
36
49
    return newdict
37
50
 
38
 
 
39
 
class PatchApply(object):
40
 
    """Patch application as a kind of content change"""
41
 
    def __init__(self, contents):
42
 
        """Constructor.
43
 
 
44
 
        :param contents: The text of the patch to apply
45
 
        :type contents: str"""
46
 
        self.contents = contents
47
 
 
48
 
    def __eq__(self, other):
49
 
        if not isinstance(other, PatchApply):
50
 
            return False
51
 
        elif self.contents != other.contents:
52
 
            return False
53
 
        else:
54
 
            return True
55
 
 
56
 
    def __ne__(self, other):
57
 
        return not (self == other)
58
 
 
59
 
    def apply(self, filename, conflict_handler, reverse=False):
60
 
        """Applies the patch to the specified file.
61
 
 
62
 
        :param filename: the file to apply the patch to
63
 
        :type filename: str
64
 
        :param reverse: If true, apply the patch in reverse
65
 
        :type reverse: bool
66
 
        """
67
 
        input_name = filename+".orig"
68
 
        try:
69
 
            os.rename(filename, input_name)
70
 
        except OSError, e:
71
 
            if e.errno != errno.ENOENT:
72
 
                raise
73
 
            if conflict_handler.patch_target_missing(filename, self.contents)\
74
 
                == "skip":
75
 
                return
76
 
            os.rename(filename, input_name)
77
 
            
78
 
 
79
 
        status = patch.patch(self.contents, input_name, filename, 
80
 
                                    reverse)
81
 
        os.chmod(filename, os.stat(input_name).st_mode)
82
 
        if status == 0:
83
 
            os.unlink(input_name)
84
 
        elif status == 1:
85
 
            conflict_handler.failed_hunks(filename)
86
 
 
87
 
        
88
 
class ChangeUnixPermissions(object):
 
51
       
 
52
class ChangeExecFlag(object):
89
53
    """This is two-way change, suitable for file modification, creation,
90
54
    deletion"""
91
 
    def __init__(self, old_mode, new_mode):
92
 
        self.old_mode = old_mode
93
 
        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
94
58
 
95
59
    def apply(self, filename, conflict_handler, reverse=False):
96
60
        if not reverse:
97
 
            from_mode = self.old_mode
98
 
            to_mode = self.new_mode
 
61
            from_exec_flag = self.old_exec_flag
 
62
            to_exec_flag = self.new_exec_flag
99
63
        else:
100
 
            from_mode = self.new_mode
101
 
            to_mode = self.old_mode
 
64
            from_exec_flag = self.new_exec_flag
 
65
            to_exec_flag = self.old_exec_flag
102
66
        try:
103
 
            current_mode = os.stat(filename).st_mode &0777
 
67
            current_exec_flag = bool(os.stat(filename).st_mode & 0111)
104
68
        except OSError, e:
105
69
            if e.errno == errno.ENOENT:
106
 
                if conflict_handler.missing_for_chmod(filename) == "skip":
 
70
                if conflict_handler.missing_for_exec_flag(filename) == "skip":
107
71
                    return
108
72
                else:
109
 
                    current_mode = from_mode
 
73
                    current_exec_flag = from_exec_flag
110
74
 
111
 
        if from_mode is not None and current_mode != from_mode:
112
 
            if conflict_handler.wrong_old_perms(filename, from_mode, 
113
 
                                                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":
114
78
                return
115
79
 
116
 
        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
117
93
            try:
118
94
                os.chmod(filename, to_mode)
119
95
            except IOError, e:
120
96
                if e.errno == errno.ENOENT:
121
 
                    conflict_handler.missing_for_chmod(filename)
 
97
                    conflict_handler.missing_for_exec_flag(filename)
122
98
 
123
99
    def __eq__(self, other):
124
 
        if not isinstance(other, ChangeUnixPermissions):
125
 
            return False
126
 
        elif self.old_mode != other.old_mode:
127
 
            return False
128
 
        elif self.new_mode != other.new_mode:
129
 
            return False
130
 
        else:
131
 
            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)
132
103
 
133
104
    def __ne__(self, other):
134
105
        return not (self == other)
135
106
 
 
107
 
136
108
def dir_create(filename, conflict_handler, reverse):
137
109
    """Creates the directory, or deletes it if reverse is true.  Intended to be
138
110
    used with ReplaceContents.
158
130
        try:
159
131
            os.rmdir(filename)
160
132
        except OSError, e:
161
 
            if e.errno != 39:
 
133
            if e.errno != errno.ENOTEMPTY:
162
134
                raise
163
135
            if conflict_handler.rmdir_non_empty(filename) == "skip":
164
136
                return
165
137
            os.rmdir(filename)
166
138
 
167
 
                
168
 
            
169
139
 
170
140
class SymlinkCreate(object):
171
141
    """Creates or deletes a symlink (for use with ReplaceContents)"""
177
147
        """
178
148
        self.target = contents
179
149
 
 
150
    def __repr__(self):
 
151
        return "SymlinkCreate(%s)" % self.target
 
152
 
180
153
    def __call__(self, filename, conflict_handler, reverse):
181
154
        """Creates or destroys the symlink.
182
155
 
264
237
 
265
238
                    
266
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
 
267
306
def reversed(sequence):
268
307
    max = len(sequence) - 1
269
308
    for i in range(len(sequence)):
336
375
            if mode is not None:
337
376
                os.chmod(filename, mode)
338
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
 
339
384
class ApplySequence(object):
340
385
    def __init__(self, changes=None):
341
386
        self.changes = []
367
412
 
368
413
 
369
414
class Diff3Merge(object):
370
 
    def __init__(self, base_file, other_file):
371
 
        self.base_file = base_file
372
 
        self.other_file = other_file
 
415
    history_based = False
 
416
    def __init__(self, file_id, base, other):
 
417
        self.file_id = file_id
 
418
        self.base = base
 
419
        self.other = other
 
420
 
 
421
    def is_creation(self):
 
422
        return False
 
423
 
 
424
    def is_deletion(self):
 
425
        return False
373
426
 
374
427
    def __eq__(self, other):
375
428
        if not isinstance(other, Diff3Merge):
376
429
            return False
377
 
        return (self.base_file == other.base_file and 
378
 
                self.other_file == other.other_file)
 
430
        return (self.base == other.base and 
 
431
                self.other == other.other and self.file_id == other.file_id)
379
432
 
380
433
    def __ne__(self, other):
381
434
        return not (self == other)
382
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
 
383
444
    def apply(self, filename, conflict_handler, reverse=False):
384
 
        new_file = filename+".new" 
385
 
        if not reverse:
386
 
            base = self.base_file
387
 
            other = self.other_file
388
 
        else:
389
 
            base = self.other_file
390
 
            other = self.base_file
391
 
        status = patch.diff3(new_file, filename, base, other)
392
 
        if status == 0:
393
 
            os.chmod(new_file, os.stat(filename).st_mode)
394
 
            os.rename(new_file, filename)
395
 
            return
396
 
        else:
397
 
            assert(status == 1)
398
 
            conflict_handler.merge_conflict(new_file, filename, base, other)
 
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)
399
475
 
400
476
 
401
477
def CreateDir():
434
510
    """
435
511
    return ReplaceContents(FileCreate(contents), None)
436
512
 
437
 
def ReplaceFileContents(old_contents, new_contents):
 
513
def ReplaceFileContents(old_tree, new_tree, file_id):
438
514
    """Convenience fucntion to replace the contents of a file.
439
515
    
440
516
    :param old_contents: The contents of the file to replace 
444
520
    :return: A ReplaceContents that will replace the contents of a file a file 
445
521
    :rtype: `ReplaceContents`
446
522
    """
447
 
    return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
 
523
    return ReplaceContents(TreeFileCreate(old_tree, file_id), 
 
524
                           TreeFileCreate(new_tree, file_id))
448
525
 
449
526
def CreateSymlink(target):
450
527
    """Convenience fucntion to create a symlink.
556
633
        if self.id  == self.parent:
557
634
            raise ParentIDIsSelf(self)
558
635
 
559
 
    def __str__(self):
 
636
    def __repr__(self):
560
637
        return "ChangesetEntry(%s)" % self.id
561
638
 
 
639
    __str__ = __repr__
 
640
 
562
641
    def __get_dir(self):
563
642
        if self.path is None:
564
643
            return None
613
692
        :param reverse: if true, the changeset is being applied in reverse
614
693
        :rtype: bool
615
694
        """
616
 
        return ((self.new_parent is None and not reverse) or 
617
 
                (self.parent is None and reverse))
 
695
        return self.is_creation(not reverse)
618
696
 
619
697
    def is_creation(self, reverse):
620
698
        """Return true if applying the entry would create a file/directory.
622
700
        :param reverse: if true, the changeset is being applied in reverse
623
701
        :rtype: bool
624
702
        """
625
 
        return ((self.parent is None and not reverse) or 
626
 
                (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()
627
709
 
628
710
    def is_creation_or_deletion(self):
629
711
        """Return true if applying the entry would create or delete a 
631
713
 
632
714
        :rtype: bool
633
715
        """
634
 
        return self.parent is None or self.new_parent is None
 
716
        return self.is_creation(False) or self.is_deletion(False)
635
717
 
636
718
    def get_cset_path(self, mod=False):
637
719
        """Determine the path of the entry according to the changeset.
657
739
                return None
658
740
            return self.path
659
741
 
660
 
    def summarize_name(self, changeset, reverse=False):
 
742
    def summarize_name(self, reverse=False):
661
743
        """Produce a one-line summary of the filename.  Indicates renames as
662
744
        old => new, indicates creation as None => new, indicates deletion as
663
745
        old => None.
670
752
        """
671
753
        orig_path = self.get_cset_path(False)
672
754
        mod_path = self.get_cset_path(True)
673
 
        if orig_path is not None:
 
755
        if orig_path and orig_path.startswith('./'):
674
756
            orig_path = orig_path[2:]
675
 
        if mod_path is not None:
 
757
        if mod_path and mod_path.startswith('./'):
676
758
            mod_path = mod_path[2:]
677
759
        if orig_path == mod_path:
678
760
            return orig_path
694
776
        :type reverse: bool
695
777
        :rtype: str
696
778
        """
697
 
        mutter("Finding new path for %s" % self.summarize_name(changeset))
 
779
        mutter("Finding new path for %s", self.summarize_name())
698
780
        if reverse:
699
781
            parent = self.parent
700
782
            to_dir = self.dir
712
794
            return None
713
795
 
714
796
        if parent == NULL_ID or parent is None:
715
 
            if to_name != '.':
 
797
            if to_name != u'.':
716
798
                raise SourceRootHasName(self, to_name)
717
799
            else:
718
 
                return '.'
719
 
        if from_dir == to_dir:
 
800
                return u'.'
 
801
        parent_entry = changeset.entries.get(parent)
 
802
        if parent_entry is None:
720
803
            dir = os.path.dirname(id_map[self.id])
721
804
        else:
722
 
            mutter("path, new_path: %r %r" % (self.path, self.new_path))
723
 
            parent_entry = changeset.entries[parent]
 
805
            mutter("path, new_path: %r %r", self.path, self.new_path)
724
806
            dir = parent_entry.get_new_path(id_map, changeset, reverse)
725
807
        if from_name == to_name:
726
808
            name = os.path.basename(id_map[self.id])
809
891
    :rtype: (List, List)
810
892
    """
811
893
    source_entries = [x for x in changeset.entries.itervalues() 
812
 
                      if x.needs_rename()]
 
894
                      if x.needs_rename() or x.is_creation_or_deletion()]
813
895
    # these are done from longest path to shortest, to avoid deleting a
814
896
    # parent before its children are deleted/renamed 
815
897
    def longest_to_shortest(entry):
856
938
            entry.apply(path, conflict_handler, reverse)
857
939
            temp_name[entry.id] = None
858
940
 
859
 
        else:
 
941
        elif entry.needs_rename():
 
942
            if entry.is_creation(reverse):
 
943
                continue
860
944
            to_name = os.path.join(temp_dir, str(i))
861
945
            src_path = inventory.get(entry.id)
862
946
            if src_path is not None:
863
947
                src_path = os.path.join(dir, src_path)
864
948
                try:
865
 
                    os.rename(src_path, to_name)
 
949
                    rename(src_path, to_name)
866
950
                    temp_name[entry.id] = to_name
867
951
                except OSError, e:
868
952
                    if e.errno != errno.ENOENT:
869
953
                        raise
870
 
                    if conflict_handler.missing_for_rename(src_path) == "skip":
 
954
                    if conflict_handler.missing_for_rename(src_path, to_name) \
 
955
                        == "skip":
871
956
                        continue
872
957
 
873
958
    return temp_name
894
979
            continue
895
980
        new_path = os.path.join(dir, new_tree_path)
896
981
        old_path = changed_inventory.get(entry.id)
897
 
        if os.path.exists(new_path):
 
982
        if bzrlib.osutils.lexists(new_path):
898
983
            if conflict_handler.target_exists(entry, new_path, old_path) == \
899
984
                "skip":
900
985
                continue
901
986
        if entry.is_creation(reverse):
902
987
            entry.apply(new_path, conflict_handler, reverse)
903
988
            changed_inventory[entry.id] = new_tree_path
904
 
        else:
 
989
        elif entry.needs_rename():
 
990
            if entry.is_deletion(reverse):
 
991
                continue
905
992
            if old_path is None:
906
993
                continue
907
994
            try:
908
 
                os.rename(old_path, new_path)
 
995
                mutter('rename %s to final name %s', old_path, new_path)
 
996
                rename(old_path, new_path)
909
997
                changed_inventory[entry.id] = new_tree_path
910
998
            except OSError, e:
911
 
                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))
912
1001
 
913
1002
class TargetExists(Exception):
914
1003
    def __init__(self, entry, target):
946
1035
        Exception.__init__(self, "Conflict applying changes to %s" % this_path)
947
1036
        self.this_path = this_path
948
1037
 
949
 
class MergePermissionConflict(Exception):
950
 
    def __init__(self, this_path, base_path, other_path):
951
 
        this_perms = os.stat(this_path).st_mode & 0755
952
 
        base_perms = os.stat(base_path).st_mode & 0755
953
 
        other_perms = os.stat(other_path).st_mode & 0755
954
 
        msg = """Conflicting permission for %s
955
 
this: %o
956
 
base: %o
957
 
other: %o
958
 
        """ % (this_path, this_perms, base_perms, other_perms)
959
 
        self.this_path = this_path
960
 
        self.base_path = base_path
961
 
        self.other_path = other_path
962
 
        Exception.__init__(self, msg)
963
 
 
964
1038
class WrongOldContents(Exception):
965
1039
    def __init__(self, filename):
966
1040
        msg = "Contents mismatch deleting %s" % filename
967
1041
        self.filename = filename
968
1042
        Exception.__init__(self, msg)
969
1043
 
970
 
class WrongOldPermissions(Exception):
971
 
    def __init__(self, filename, old_perms, new_perms):
972
 
        msg = "Permission missmatch on %s:\n" \
973
 
        "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)
974
1048
        self.filename = filename
975
1049
        Exception.__init__(self, msg)
976
1050
 
994
1068
        Exception.__init__(self, msg)
995
1069
        self.filename = filename
996
1070
 
997
 
class MissingPermsFile(Exception):
 
1071
class MissingForSetExec(Exception):
998
1072
    def __init__(self, filename):
999
1073
        msg = "Attempt to change permissions on  %s, which does not exist" %\
1000
1074
            filename
1009
1083
 
1010
1084
 
1011
1085
class MissingForRename(Exception):
1012
 
    def __init__(self, filename):
1013
 
        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)
1014
1088
        Exception.__init__(self, msg)
1015
1089
        self.filename = filename
1016
1090
 
1019
1093
        msg = "Conflicting contents for new file %s" % (filename)
1020
1094
        Exception.__init__(self, msg)
1021
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
 
1022
1106
 
1023
1107
class MissingForMerge(Exception):
1024
1108
    def __init__(self, filename):
1028
1112
 
1029
1113
 
1030
1114
class ExceptionConflictHandler(object):
1031
 
    def __init__(self, dir):
1032
 
        self.dir = dir
1033
 
    
 
1115
    """Default handler for merge exceptions.
 
1116
 
 
1117
    This throws an error on any kind of conflict.  Conflict handlers can
 
1118
    descend from this class if they have a better way to handle some or
 
1119
    all types of conflict.
 
1120
    """
1034
1121
    def missing_parent(self, pathname):
1035
1122
        parent = os.path.dirname(pathname)
1036
1123
        raise Exception("Parent directory missing for %s" % pathname)
1047
1134
    def rename_conflict(self, id, this_name, base_name, other_name):
1048
1135
        raise RenameConflict(id, this_name, base_name, other_name)
1049
1136
 
1050
 
    def move_conflict(self, id, inventory):
1051
 
        this_dir = inventory.this.get_dir(id)
1052
 
        base_dir = inventory.base.get_dir(id)
1053
 
        other_dir = inventory.other.get_dir(id)
 
1137
    def move_conflict(self, id, this_dir, base_dir, other_dir):
1054
1138
        raise MoveConflict(id, this_dir, base_dir, other_dir)
1055
1139
 
1056
 
    def merge_conflict(self, new_file, this_path, base_path, other_path):
 
1140
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1057
1141
        os.unlink(new_file)
1058
1142
        raise MergeConflict(this_path)
1059
1143
 
1060
 
    def permission_conflict(self, this_path, base_path, other_path):
1061
 
        raise MergePermissionConflict(this_path, base_path, other_path)
1062
 
 
1063
1144
    def wrong_old_contents(self, filename, expected_contents):
1064
1145
        raise WrongOldContents(filename)
1065
1146
 
1066
1147
    def rem_contents_conflict(self, filename, this_contents, base_contents):
1067
1148
        raise RemoveContentsConflict(filename)
1068
1149
 
1069
 
    def wrong_old_perms(self, filename, old_perms, new_perms):
1070
 
        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)
1071
1152
 
1072
1153
    def rmdir_non_empty(self, filename):
1073
1154
        raise DeletingNonEmptyDirectory(filename)
1078
1159
    def patch_target_missing(self, filename, contents):
1079
1160
        raise PatchTargetMissing(filename)
1080
1161
 
1081
 
    def missing_for_chmod(self, filename):
1082
 
        raise MissingPermsFile(filename)
 
1162
    def missing_for_exec_flag(self, filename):
 
1163
        raise MissingForExecFlag(filename)
1083
1164
 
1084
1165
    def missing_for_rm(self, filename, change):
1085
1166
        raise MissingForRm(filename)
1086
1167
 
1087
 
    def missing_for_rename(self, filename):
1088
 
        raise MissingForRename(filename)
 
1168
    def missing_for_rename(self, filename, to_path):
 
1169
        raise MissingForRename(filename, to_path)
1089
1170
 
1090
 
    def missing_for_merge(self, file_id, inventory):
1091
 
        raise MissingForMerge(inventory.other.get_path(file_id))
 
1171
    def missing_for_merge(self, file_id, other_path):
 
1172
        raise MissingForMerge(other_path)
1092
1173
 
1093
1174
    def new_contents_conflict(self, filename, other_contents):
1094
1175
        raise NewContentsConflict(filename)
1095
1176
 
1096
 
    def finalize():
 
1177
    def weave_merge_conflict(self, filename, weave, other_i, out_file):
 
1178
        raise WeaveMergeConflict(filename)
 
1179
 
 
1180
    def threeway_contents_conflict(self, filename, this_contents,
 
1181
                                   base_contents, other_contents):
 
1182
        raise ThreewayContentsConflict(filename)
 
1183
 
 
1184
    def finalize(self):
1097
1185
        pass
1098
1186
 
1099
1187
def apply_changeset(changeset, inventory, dir, conflict_handler=None, 
1112
1200
    :rtype: Dictionary
1113
1201
    """
1114
1202
    if conflict_handler is None:
1115
 
        conflict_handler = ExceptionConflictHandler(dir)
 
1203
        conflict_handler = ExceptionConflictHandler()
1116
1204
    temp_dir = os.path.join(dir, "bzr-tree-change")
1117
1205
    try:
1118
1206
        os.mkdir(temp_dir)
1129
1217
    
1130
1218
    #apply changes that don't affect filenames
1131
1219
    for entry in changeset.entries.itervalues():
1132
 
        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
1133
1225
            path = os.path.join(dir, inventory[entry.id])
1134
1226
            entry.apply(path, conflict_handler, reverse)
1135
1227
 
1154
1246
    r_inventory = {}
1155
1247
    for entry in tree.source_inventory().itervalues():
1156
1248
        inventory[entry.id] = entry.path
1157
 
    new_inventory = apply_changeset(cset, r_inventory, tree.root,
 
1249
    new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
1158
1250
                                    reverse=reverse)
1159
1251
    new_entries, remove_entries = \
1160
1252
        get_inventory_change(inventory, new_inventory, cset, reverse)
1295
1387
        return new_meta
1296
1388
    elif new_meta is None:
1297
1389
        return old_meta
1298
 
    elif isinstance(old_meta, ChangeUnixPermissions) and \
1299
 
        isinstance(new_meta, ChangeUnixPermissions):
1300
 
        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)
1301
1393
    else:
1302
1394
        return ApplySequence(old_meta, new_meta)
1303
1395
 
1308
1400
            return False
1309
1401
    return True
1310
1402
 
1311
 
class UnsuppportedFiletype(Exception):
1312
 
    def __init__(self, full_path, stat_result):
1313
 
        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)
1314
1407
        Exception.__init__(self, msg)
1315
1408
        self.full_path = full_path
1316
 
        self.stat_result = stat_result
1317
 
 
1318
 
def generate_changeset(tree_a, tree_b, inventory_a=None, inventory_b=None):
1319
 
    return ChangesetGenerator(tree_a, tree_b, inventory_a, inventory_b)()
 
1409
        self.kind = kind
 
1410
 
 
1411
def generate_changeset(tree_a, tree_b, interesting_ids=None):
 
1412
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
 
1413
 
1320
1414
 
1321
1415
class ChangesetGenerator(object):
1322
 
    def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
 
1416
    def __init__(self, tree_a, tree_b, interesting_ids=None):
1323
1417
        object.__init__(self)
1324
1418
        self.tree_a = tree_a
1325
1419
        self.tree_b = tree_b
1326
 
        if inventory_a is not None:
1327
 
            self.inventory_a = inventory_a
1328
 
        else:
1329
 
            self.inventory_a = tree_a.inventory()
1330
 
        if inventory_b is not None:
1331
 
            self.inventory_b = inventory_b
1332
 
        else:
1333
 
            self.inventory_b = tree_b.inventory()
1334
 
        self.r_inventory_a = self.reverse_inventory(self.inventory_a)
1335
 
        self.r_inventory_b = self.reverse_inventory(self.inventory_b)
 
1420
        self._interesting_ids = interesting_ids
1336
1421
 
1337
 
    def reverse_inventory(self, inventory):
1338
 
        r_inventory = {}
1339
 
        for entry in inventory.itervalues():
1340
 
            if entry.id is None:
1341
 
                continue
1342
 
            r_inventory[entry.id] = entry
1343
 
        return r_inventory
 
1422
    def iter_both_tree_ids(self):
 
1423
        for file_id in self.tree_a:
 
1424
            yield file_id
 
1425
        for file_id in self.tree_b:
 
1426
            if file_id not in self.tree_a:
 
1427
                yield file_id
1344
1428
 
1345
1429
    def __call__(self):
1346
1430
        cset = Changeset()
1347
 
        for entry in self.inventory_a.itervalues():
1348
 
            if entry.id is None:
1349
 
                continue
1350
 
            cs_entry = self.make_entry(entry.id)
 
1431
        for file_id in self.iter_both_tree_ids():
 
1432
            cs_entry = self.make_entry(file_id)
1351
1433
            if cs_entry is not None and not cs_entry.is_boring():
1352
1434
                cset.add_entry(cs_entry)
1353
1435
 
1354
 
        for entry in self.inventory_b.itervalues():
1355
 
            if entry.id is None:
1356
 
                continue
1357
 
            if not self.r_inventory_a.has_key(entry.id):
1358
 
                cs_entry = self.make_entry(entry.id)
1359
 
                if cs_entry is not None and not cs_entry.is_boring():
1360
 
                    cset.add_entry(cs_entry)
1361
1436
        for entry in list(cset.entries.itervalues()):
1362
1437
            if entry.parent != entry.new_parent:
1363
1438
                if not cset.entries.has_key(entry.parent) and\
1371
1446
                    cset.add_entry(parent_entry)
1372
1447
        return cset
1373
1448
 
1374
 
    def get_entry_parent(self, entry, inventory):
1375
 
        if entry is None:
1376
 
            return None
1377
 
        if entry.path == "./.":
1378
 
            return NULL_ID
1379
 
        dirname = os.path.dirname(entry.path)
1380
 
        if dirname == ".":
1381
 
            dirname = "./."
1382
 
        parent = inventory[dirname]
1383
 
        return parent.id
1384
 
 
1385
 
    def get_paths(self, entry, tree):
1386
 
        if entry is None:
1387
 
            return (None, None)
1388
 
        full_path = tree.readonly_path(entry.id)
1389
 
        if entry.path == ".":
1390
 
            return ("", full_path)
1391
 
        return (entry.path, full_path)
1392
 
 
1393
 
    def make_basic_entry(self, id, only_interesting):
1394
 
        entry_a = self.r_inventory_a.get(id)
1395
 
        entry_b = self.r_inventory_b.get(id)
 
1449
    def iter_inventory(self, tree):
 
1450
        for file_id in tree:
 
1451
            yield self.get_entry(file_id, tree)
 
1452
 
 
1453
    def get_entry(self, file_id, tree):
 
1454
        if not tree.has_or_had_id(file_id):
 
1455
            return None
 
1456
        return tree.inventory[file_id]
 
1457
 
 
1458
    def get_entry_parent(self, entry):
 
1459
        if entry is None:
 
1460
            return None
 
1461
        return entry.parent_id
 
1462
 
 
1463
    def get_path(self, file_id, tree):
 
1464
        if not tree.has_or_had_id(file_id):
 
1465
            return None
 
1466
        path = tree.id2path(file_id)
 
1467
        if path == '':
 
1468
            return './.'
 
1469
        else:
 
1470
            return path
 
1471
 
 
1472
    def make_basic_entry(self, file_id, only_interesting):
 
1473
        entry_a = self.get_entry(file_id, self.tree_a)
 
1474
        entry_b = self.get_entry(file_id, self.tree_b)
1396
1475
        if only_interesting and not self.is_interesting(entry_a, entry_b):
1397
 
            return (None, None, None)
1398
 
        parent = self.get_entry_parent(entry_a, self.inventory_a)
1399
 
        (path, full_path_a) = self.get_paths(entry_a, self.tree_a)
1400
 
        cs_entry = ChangesetEntry(id, parent, path)
1401
 
        new_parent = self.get_entry_parent(entry_b, self.inventory_b)
1402
 
 
1403
 
 
1404
 
        (new_path, full_path_b) = self.get_paths(entry_b, self.tree_b)
 
1476
            return None
 
1477
        parent = self.get_entry_parent(entry_a)
 
1478
        path = self.get_path(file_id, self.tree_a)
 
1479
        cs_entry = ChangesetEntry(file_id, parent, path)
 
1480
        new_parent = self.get_entry_parent(entry_b)
 
1481
 
 
1482
        new_path = self.get_path(file_id, self.tree_b)
1405
1483
 
1406
1484
        cs_entry.new_path = new_path
1407
1485
        cs_entry.new_parent = new_parent
1408
 
        return (cs_entry, full_path_a, full_path_b)
 
1486
        return cs_entry
1409
1487
 
1410
1488
    def is_interesting(self, entry_a, entry_b):
 
1489
        if self._interesting_ids is None:
 
1490
            return True
1411
1491
        if entry_a is not None:
1412
 
            if entry_a.interesting:
1413
 
                return True
1414
 
        if entry_b is not None:
1415
 
            if entry_b.interesting:
1416
 
                return True
1417
 
        return False
 
1492
            file_id = entry_a.file_id
 
1493
        elif entry_b is not None:
 
1494
            file_id = entry_b.file_id
 
1495
        else:
 
1496
            return False
 
1497
        return file_id in self._interesting_ids
1418
1498
 
1419
1499
    def make_boring_entry(self, id):
1420
 
        (cs_entry, full_path_a, full_path_b) = \
1421
 
            self.make_basic_entry(id, only_interesting=False)
 
1500
        cs_entry = self.make_basic_entry(id, only_interesting=False)
1422
1501
        if cs_entry.is_creation_or_deletion():
1423
1502
            return self.make_entry(id, only_interesting=False)
1424
1503
        else:
1426
1505
        
1427
1506
 
1428
1507
    def make_entry(self, id, only_interesting=True):
1429
 
        (cs_entry, full_path_a, full_path_b) = \
1430
 
            self.make_basic_entry(id, only_interesting)
 
1508
        cs_entry = self.make_basic_entry(id, only_interesting)
1431
1509
 
1432
1510
        if cs_entry is None:
1433
1511
            return None
1434
 
       
1435
 
        stat_a = self.lstat(full_path_a)
1436
 
        stat_b = self.lstat(full_path_b)
1437
 
        if stat_b is None:
1438
 
            cs_entry.new_parent = None
1439
 
            cs_entry.new_path = None
1440
 
        
1441
 
        cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1442
 
        cs_entry.contents_change = self.make_contents_change(full_path_a,
1443
 
                                                             stat_a, 
1444
 
                                                             full_path_b, 
1445
 
                                                             stat_b)
 
1512
 
 
1513
        cs_entry.metadata_change = self.make_exec_flag_change(id)
 
1514
 
 
1515
        if id in self.tree_a and id in self.tree_b:
 
1516
            a_sha1 = self.tree_a.get_file_sha1(id)
 
1517
            b_sha1 = self.tree_b.get_file_sha1(id)
 
1518
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
 
1519
                return cs_entry
 
1520
 
 
1521
        cs_entry.contents_change = self.make_contents_change(id)
1446
1522
        return cs_entry
1447
1523
 
1448
 
    def make_mode_change(self, stat_a, stat_b):
1449
 
        mode_a = None
1450
 
        if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
1451
 
            mode_a = stat_a.st_mode & 0777
1452
 
        mode_b = None
1453
 
        if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
1454
 
            mode_b = stat_b.st_mode & 0777
1455
 
        if mode_a == mode_b:
1456
 
            return None
1457
 
        return ChangeUnixPermissions(mode_a, mode_b)
1458
 
 
1459
 
    def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
1460
 
        if stat_a is None and stat_b is None:
1461
 
            return None
1462
 
        if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
1463
 
            stat.S_ISDIR(stat_b.st_mode):
1464
 
            return None
1465
 
        if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
1466
 
            stat.S_ISREG(stat_b.st_mode):
1467
 
            if stat_a.st_ino == stat_b.st_ino and \
1468
 
                stat_a.st_dev == stat_b.st_dev:
1469
 
                return None
1470
 
            if file(full_path_a, "rb").read() == \
1471
 
                file(full_path_b, "rb").read():
1472
 
                return None
1473
 
 
1474
 
            patch_contents = patch.diff(full_path_a, 
1475
 
                                        file(full_path_b, "rb").read())
1476
 
            if patch_contents is None:
1477
 
                return None
1478
 
            return PatchApply(patch_contents)
1479
 
 
1480
 
        a_contents = self.get_contents(stat_a, full_path_a)
1481
 
        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)
1482
1539
        if a_contents == b_contents:
1483
1540
            return None
1484
1541
        return ReplaceContents(a_contents, b_contents)
1485
1542
 
1486
 
    def get_contents(self, stat_result, full_path):
1487
 
        if stat_result is None:
1488
 
            return None
1489
 
        elif stat.S_ISREG(stat_result.st_mode):
1490
 
            return FileCreate(file(full_path, "rb").read())
1491
 
        elif stat.S_ISDIR(stat_result.st_mode):
1492
 
            return dir_create
1493
 
        elif stat.S_ISLNK(stat_result.st_mode):
1494
 
            return SymlinkCreate(os.readlink(full_path))
1495
 
        else:
1496
 
            raise UnsupportedFiletype(full_path, stat_result)
1497
1543
 
1498
 
    def lstat(self, full_path):
1499
 
        stat_result = None
1500
 
        if full_path is not None:
1501
 
            try:
1502
 
                stat_result = os.lstat(full_path)
1503
 
            except OSError, e:
1504
 
                if e.errno != errno.ENOENT:
1505
 
                    raise
1506
 
        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))
1507
1557
 
1508
1558
 
1509
1559
def full_path(entry, tree):
1510
 
    return os.path.join(tree.root, entry.path)
 
1560
    return os.path.join(tree.basedir, entry.path)
1511
1561
 
1512
1562
def new_delete_entry(entry, tree, inventory, delete):
1513
1563
    if entry.path == "":
1563
1613
            return None
1564
1614
        directory = self.get_dir(id)
1565
1615
        if directory == '.':
1566
 
            directory = './.'
 
1616
            directory = u'./.'
1567
1617
        if directory is None:
1568
1618
            return NULL_ID
1569
1619
        return self.get_rinventory().get(directory)