← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/changeset.py

  • Committer: John Arbash Meinel
  • Date: 2005-12-01 19:27:48 UTC
  • mto: (1185.50.19 bzr-jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1532.
  • Revision ID: john@arbash-meinel.com-20051201192748-369238cd06ecf7e8
Added osutils.mkdtemp()

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 shutil import rmtree
 
29
from itertools import izip
 
30
 
 
31
from bzrlib.trace import mutter, warning
 
32
from bzrlib.osutils import rename, sha_file, pathjoin, mkdtemp
 
33
import bzrlib
 
34
from bzrlib.errors import BzrCheckError
30
35
 
31
36
__docformat__ = "restructuredtext"
32
37
 
42
47
        newdict[value] = key
43
48
    return newdict
44
49
 
45
 
 
46
50
       
47
 
class ChangeUnixPermissions(object):
 
51
class ChangeExecFlag(object):
48
52
    """This is two-way change, suitable for file modification, creation,
49
53
    deletion"""
50
 
    def __init__(self, old_mode, new_mode):
51
 
        self.old_mode = old_mode
52
 
        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
53
57
 
54
58
    def apply(self, filename, conflict_handler, reverse=False):
55
59
        if not reverse:
56
 
            from_mode = self.old_mode
57
 
            to_mode = self.new_mode
 
60
            from_exec_flag = self.old_exec_flag
 
61
            to_exec_flag = self.new_exec_flag
58
62
        else:
59
 
            from_mode = self.new_mode
60
 
            to_mode = self.old_mode
 
63
            from_exec_flag = self.new_exec_flag
 
64
            to_exec_flag = self.old_exec_flag
61
65
        try:
62
 
            current_mode = os.stat(filename).st_mode &0777
 
66
            current_exec_flag = bool(os.stat(filename).st_mode & 0111)
63
67
        except OSError, e:
64
68
            if e.errno == errno.ENOENT:
65
 
                if conflict_handler.missing_for_chmod(filename) == "skip":
 
69
                if conflict_handler.missing_for_exec_flag(filename) == "skip":
66
70
                    return
67
71
                else:
68
 
                    current_mode = from_mode
 
72
                    current_exec_flag = from_exec_flag
69
73
 
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":
 
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":
73
77
                return
74
78
 
75
 
        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
76
92
            try:
77
93
                os.chmod(filename, to_mode)
78
94
            except IOError, e:
79
95
                if e.errno == errno.ENOENT:
80
 
                    conflict_handler.missing_for_chmod(filename)
 
96
                    conflict_handler.missing_for_exec_flag(filename)
81
97
 
82
98
    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
 
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)
91
102
 
92
103
    def __ne__(self, other):
93
104
        return not (self == other)
94
105
 
 
106
 
95
107
def dir_create(filename, conflict_handler, reverse):
96
108
    """Creates the directory, or deletes it if reverse is true.  Intended to be
97
109
    used with ReplaceContents.
117
129
        try:
118
130
            os.rmdir(filename)
119
131
        except OSError, e:
120
 
            if e.errno != 39:
 
132
            if e.errno != errno.ENOTEMPTY:
121
133
                raise
122
134
            if conflict_handler.rmdir_non_empty(filename) == "skip":
123
135
                return
124
136
            os.rmdir(filename)
125
137
 
126
 
                
127
 
            
128
138
 
129
139
class SymlinkCreate(object):
130
140
    """Creates or deletes a symlink (for use with ReplaceContents)"""
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 = pathjoin(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
 
            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)
 
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.
525
632
        if self.id  == self.parent:
526
633
            raise ParentIDIsSelf(self)
527
634
 
528
 
    def __str__(self):
 
635
    def __repr__(self):
529
636
        return "ChangesetEntry(%s)" % self.id
530
637
 
 
638
    __str__ = __repr__
 
639
 
531
640
    def __get_dir(self):
532
641
        if self.path is None:
533
642
            return None
534
643
        return os.path.dirname(self.path)
535
644
 
536
645
    def __set_dir(self, dir):
537
 
        self.path = os.path.join(dir, os.path.basename(self.path))
 
646
        self.path = pathjoin(dir, os.path.basename(self.path))
538
647
 
539
648
    dir = property(__get_dir, __set_dir)
540
649
    
544
653
        return os.path.basename(self.path)
545
654
 
546
655
    def __set_name(self, name):
547
 
        self.path = os.path.join(os.path.dirname(self.path), name)
 
656
        self.path = pathjoin(os.path.dirname(self.path), name)
548
657
 
549
658
    name = property(__get_name, __set_name)
550
659
 
554
663
        return os.path.dirname(self.new_path)
555
664
 
556
665
    def __set_new_dir(self, dir):
557
 
        self.new_path = os.path.join(dir, os.path.basename(self.new_path))
 
666
        self.new_path = pathjoin(dir, os.path.basename(self.new_path))
558
667
 
559
668
    new_dir = property(__get_new_dir, __set_new_dir)
560
669
 
564
673
        return os.path.basename(self.new_path)
565
674
 
566
675
    def __set_new_name(self, name):
567
 
        self.new_path = os.path.join(os.path.dirname(self.new_path), name)
 
676
        self.new_path = pathjoin(os.path.dirname(self.new_path), name)
568
677
 
569
678
    new_name = property(__get_new_name, __set_new_name)
570
679
 
582
691
        :param reverse: if true, the changeset is being applied in reverse
583
692
        :rtype: bool
584
693
        """
585
 
        return ((self.new_parent is None and not reverse) or 
586
 
                (self.parent is None and reverse))
 
694
        return self.is_creation(not reverse)
587
695
 
588
696
    def is_creation(self, reverse):
589
697
        """Return true if applying the entry would create a file/directory.
591
699
        :param reverse: if true, the changeset is being applied in reverse
592
700
        :rtype: bool
593
701
        """
594
 
        return ((self.parent is None and not reverse) or 
595
 
                (self.new_parent is None and reverse))
 
702
        if self.contents_change is None:
 
703
            return False
 
704
        if reverse:
 
705
            return self.contents_change.is_deletion()
 
706
        else:
 
707
            return self.contents_change.is_creation()
596
708
 
597
709
    def is_creation_or_deletion(self):
598
710
        """Return true if applying the entry would create or delete a 
600
712
 
601
713
        :rtype: bool
602
714
        """
603
 
        return self.parent is None or self.new_parent is None
 
715
        return self.is_creation(False) or self.is_deletion(False)
604
716
 
605
717
    def get_cset_path(self, mod=False):
606
718
        """Determine the path of the entry according to the changeset.
639
751
        """
640
752
        orig_path = self.get_cset_path(False)
641
753
        mod_path = self.get_cset_path(True)
642
 
        if orig_path is not None:
 
754
        if orig_path and orig_path.startswith('./'):
643
755
            orig_path = orig_path[2:]
644
 
        if mod_path is not None:
 
756
        if mod_path and mod_path.startswith('./'):
645
757
            mod_path = mod_path[2:]
646
758
        if orig_path == mod_path:
647
759
            return orig_path
663
775
        :type reverse: bool
664
776
        :rtype: str
665
777
        """
666
 
        mutter("Finding new path for %s" % self.summarize_name())
 
778
        mutter("Finding new path for %s", self.summarize_name())
667
779
        if reverse:
668
780
            parent = self.parent
669
781
            to_dir = self.dir
681
793
            return None
682
794
 
683
795
        if parent == NULL_ID or parent is None:
684
 
            if to_name != '.':
 
796
            if to_name != u'.':
685
797
                raise SourceRootHasName(self, to_name)
686
798
            else:
687
 
                return '.'
688
 
        if from_dir == to_dir:
 
799
                return u'.'
 
800
        parent_entry = changeset.entries.get(parent)
 
801
        if parent_entry is None:
689
802
            dir = os.path.dirname(id_map[self.id])
690
803
        else:
691
 
            mutter("path, new_path: %r %r" % (self.path, self.new_path))
692
 
            parent_entry = changeset.entries[parent]
 
804
            mutter("path, new_path: %r %r", self.path, self.new_path)
693
805
            dir = parent_entry.get_new_path(id_map, changeset, reverse)
694
806
        if from_name == to_name:
695
807
            name = os.path.basename(id_map[self.id])
696
808
        else:
697
809
            name = to_name
698
810
            assert(from_name is None or from_name == os.path.basename(id_map[self.id]))
699
 
        return os.path.join(dir, name)
 
811
        return pathjoin(dir, name)
700
812
 
701
813
    def is_boring(self):
702
814
        """Determines whether the entry does nothing
778
890
    :rtype: (List, List)
779
891
    """
780
892
    source_entries = [x for x in changeset.entries.itervalues() 
781
 
                      if x.needs_rename()]
 
893
                      if x.needs_rename() or x.is_creation_or_deletion()]
782
894
    # these are done from longest path to shortest, to avoid deleting a
783
895
    # parent before its children are deleted/renamed 
784
896
    def longest_to_shortest(entry):
821
933
    for i in range(len(source_entries)):
822
934
        entry = source_entries[i]
823
935
        if entry.is_deletion(reverse):
824
 
            path = os.path.join(dir, inventory[entry.id])
 
936
            path = pathjoin(dir, inventory[entry.id])
825
937
            entry.apply(path, conflict_handler, reverse)
826
938
            temp_name[entry.id] = None
827
939
 
828
 
        else:
829
 
            to_name = os.path.join(temp_dir, str(i))
 
940
        elif entry.needs_rename():
 
941
            if entry.is_creation(reverse):
 
942
                continue
 
943
            to_name = pathjoin(temp_dir, str(i))
830
944
            src_path = inventory.get(entry.id)
831
945
            if src_path is not None:
832
 
                src_path = os.path.join(dir, src_path)
 
946
                src_path = pathjoin(dir, src_path)
833
947
                try:
834
 
                    os.rename(src_path, to_name)
 
948
                    rename(src_path, to_name)
835
949
                    temp_name[entry.id] = to_name
836
950
                except OSError, e:
837
951
                    if e.errno != errno.ENOENT:
838
952
                        raise
839
 
                    if conflict_handler.missing_for_rename(src_path) == "skip":
 
953
                    if conflict_handler.missing_for_rename(src_path, to_name) \
 
954
                        == "skip":
840
955
                        continue
841
956
 
842
957
    return temp_name
861
976
        new_tree_path = entry.get_new_path(inventory, changeset, reverse)
862
977
        if new_tree_path is None:
863
978
            continue
864
 
        new_path = os.path.join(dir, new_tree_path)
 
979
        new_path = pathjoin(dir, new_tree_path)
865
980
        old_path = changed_inventory.get(entry.id)
866
 
        if os.path.exists(new_path):
 
981
        if bzrlib.osutils.lexists(new_path):
867
982
            if conflict_handler.target_exists(entry, new_path, old_path) == \
868
983
                "skip":
869
984
                continue
870
985
        if entry.is_creation(reverse):
871
986
            entry.apply(new_path, conflict_handler, reverse)
872
987
            changed_inventory[entry.id] = new_tree_path
873
 
        else:
 
988
        elif entry.needs_rename():
 
989
            if entry.is_deletion(reverse):
 
990
                continue
874
991
            if old_path is None:
875
992
                continue
876
993
            try:
877
 
                os.rename(old_path, new_path)
 
994
                mutter('rename %s to final name %s', old_path, new_path)
 
995
                rename(old_path, new_path)
878
996
                changed_inventory[entry.id] = new_tree_path
879
997
            except OSError, e:
880
 
                raise Exception ("%s is missing" % new_path)
 
998
                raise BzrCheckError('failed to rename %s to %s for changeset entry %s: %s'
 
999
                        % (old_path, new_path, entry, e))
881
1000
 
882
1001
class TargetExists(Exception):
883
1002
    def __init__(self, entry, target):
915
1034
        Exception.__init__(self, "Conflict applying changes to %s" % this_path)
916
1035
        self.this_path = this_path
917
1036
 
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
1037
class WrongOldContents(Exception):
934
1038
    def __init__(self, filename):
935
1039
        msg = "Contents mismatch deleting %s" % filename
936
1040
        self.filename = filename
937
1041
        Exception.__init__(self, msg)
938
1042
 
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)
 
1043
class WrongOldExecFlag(Exception):
 
1044
    def __init__(self, filename, old_exec_flag, new_exec_flag):
 
1045
        msg = "Executable flag missmatch on %s:\n" \
 
1046
        "Expected %s, got %s." % (filename, old_exec_flag, new_exec_flag)
943
1047
        self.filename = filename
944
1048
        Exception.__init__(self, msg)
945
1049
 
963
1067
        Exception.__init__(self, msg)
964
1068
        self.filename = filename
965
1069
 
966
 
class MissingPermsFile(Exception):
 
1070
class MissingForSetExec(Exception):
967
1071
    def __init__(self, filename):
968
1072
        msg = "Attempt to change permissions on  %s, which does not exist" %\
969
1073
            filename
978
1082
 
979
1083
 
980
1084
class MissingForRename(Exception):
981
 
    def __init__(self, filename):
982
 
        msg = "Attempt to move missing path %s" % (filename)
 
1085
    def __init__(self, filename, to_path):
 
1086
        msg = "Attempt to move missing path %s to %s" % (filename, to_path)
983
1087
        Exception.__init__(self, msg)
984
1088
        self.filename = filename
985
1089
 
988
1092
        msg = "Conflicting contents for new file %s" % (filename)
989
1093
        Exception.__init__(self, msg)
990
1094
 
 
1095
class WeaveMergeConflict(Exception):
 
1096
    def __init__(self, filename):
 
1097
        msg = "Conflicting contents for file %s" % (filename)
 
1098
        Exception.__init__(self, msg)
 
1099
 
 
1100
class ThreewayContentsConflict(Exception):
 
1101
    def __init__(self, filename):
 
1102
        msg = "Conflicting contents for file %s" % (filename)
 
1103
        Exception.__init__(self, msg)
 
1104
 
991
1105
 
992
1106
class MissingForMerge(Exception):
993
1107
    def __init__(self, filename):
1003
1117
    descend from this class if they have a better way to handle some or
1004
1118
    all types of conflict.
1005
1119
    """
1006
 
    def __init__(self, dir):
1007
 
        self.dir = dir
1008
 
    
1009
1120
    def missing_parent(self, pathname):
1010
1121
        parent = os.path.dirname(pathname)
1011
1122
        raise Exception("Parent directory missing for %s" % pathname)
1029
1140
        os.unlink(new_file)
1030
1141
        raise MergeConflict(this_path)
1031
1142
 
1032
 
    def permission_conflict(self, this_path, base_path, other_path):
1033
 
        raise MergePermissionConflict(this_path, base_path, other_path)
1034
 
 
1035
1143
    def wrong_old_contents(self, filename, expected_contents):
1036
1144
        raise WrongOldContents(filename)
1037
1145
 
1038
1146
    def rem_contents_conflict(self, filename, this_contents, base_contents):
1039
1147
        raise RemoveContentsConflict(filename)
1040
1148
 
1041
 
    def wrong_old_perms(self, filename, old_perms, new_perms):
1042
 
        raise WrongOldPermissions(filename, old_perms, new_perms)
 
1149
    def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
 
1150
        raise WrongOldExecFlag(filename, old_exec_flag, new_exec_flag)
1043
1151
 
1044
1152
    def rmdir_non_empty(self, filename):
1045
1153
        raise DeletingNonEmptyDirectory(filename)
1050
1158
    def patch_target_missing(self, filename, contents):
1051
1159
        raise PatchTargetMissing(filename)
1052
1160
 
1053
 
    def missing_for_chmod(self, filename):
1054
 
        raise MissingPermsFile(filename)
 
1161
    def missing_for_exec_flag(self, filename):
 
1162
        raise MissingForExecFlag(filename)
1055
1163
 
1056
1164
    def missing_for_rm(self, filename, change):
1057
1165
        raise MissingForRm(filename)
1058
1166
 
1059
 
    def missing_for_rename(self, filename):
1060
 
        raise MissingForRename(filename)
 
1167
    def missing_for_rename(self, filename, to_path):
 
1168
        raise MissingForRename(filename, to_path)
1061
1169
 
1062
1170
    def missing_for_merge(self, file_id, other_path):
1063
1171
        raise MissingForMerge(other_path)
1065
1173
    def new_contents_conflict(self, filename, other_contents):
1066
1174
        raise NewContentsConflict(filename)
1067
1175
 
 
1176
    def weave_merge_conflict(self, filename, weave, other_i, out_file):
 
1177
        raise WeaveMergeConflict(filename)
 
1178
 
 
1179
    def threeway_contents_conflict(self, filename, this_contents,
 
1180
                                   base_contents, other_contents):
 
1181
        raise ThreewayContentsConflict(filename)
 
1182
 
1068
1183
    def finalize(self):
1069
1184
        pass
1070
1185
 
1084
1199
    :rtype: Dictionary
1085
1200
    """
1086
1201
    if conflict_handler is None:
1087
 
        conflict_handler = ExceptionConflictHandler(dir)
1088
 
    temp_dir = os.path.join(dir, "bzr-tree-change")
 
1202
        conflict_handler = ExceptionConflictHandler()
 
1203
    temp_dir = pathjoin(dir, "bzr-tree-change")
1089
1204
    try:
1090
1205
        os.mkdir(temp_dir)
1091
1206
    except OSError, e:
1101
1216
    
1102
1217
    #apply changes that don't affect filenames
1103
1218
    for entry in changeset.entries.itervalues():
1104
 
        if not entry.is_creation_or_deletion():
1105
 
            path = os.path.join(dir, inventory[entry.id])
 
1219
        if not entry.is_creation_or_deletion() and not entry.is_boring():
 
1220
            if entry.id not in inventory:
 
1221
                warning("entry {%s} no longer present, can't be updated",
 
1222
                        entry.id)
 
1223
                continue
 
1224
            path = pathjoin(dir, inventory[entry.id])
1106
1225
            entry.apply(path, conflict_handler, reverse)
1107
1226
 
1108
1227
    # Apply renames in stages, to minimize conflicts:
1126
1245
    r_inventory = {}
1127
1246
    for entry in tree.source_inventory().itervalues():
1128
1247
        inventory[entry.id] = entry.path
1129
 
    new_inventory = apply_changeset(cset, r_inventory, tree.root,
 
1248
    new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
1130
1249
                                    reverse=reverse)
1131
1250
    new_entries, remove_entries = \
1132
1251
        get_inventory_change(inventory, new_inventory, cset, reverse)
1267
1386
        return new_meta
1268
1387
    elif new_meta is None:
1269
1388
        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)
 
1389
    elif (isinstance(old_meta, ChangeExecFlag) and
 
1390
          isinstance(new_meta, ChangeExecFlag)):
 
1391
        return ChangeExecFlag(old_meta.old_exec_flag, new_meta.new_exec_flag)
1273
1392
    else:
1274
1393
        return ApplySequence(old_meta, new_meta)
1275
1394
 
1280
1399
            return False
1281
1400
    return True
1282
1401
 
1283
 
class UnsuppportedFiletype(Exception):
1284
 
    def __init__(self, full_path, stat_result):
1285
 
        msg = "The file \"%s\" is not a supported filetype." % full_path
 
1402
class UnsupportedFiletype(Exception):
 
1403
    def __init__(self, kind, full_path):
 
1404
        msg = "The file \"%s\" is a %s, which is not a supported filetype." \
 
1405
            % (full_path, kind)
1286
1406
        Exception.__init__(self, msg)
1287
1407
        self.full_path = full_path
1288
 
        self.stat_result = stat_result
 
1408
        self.kind = kind
1289
1409
 
1290
1410
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1291
1411
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1292
1412
 
 
1413
 
1293
1414
class ChangesetGenerator(object):
1294
1415
    def __init__(self, tree_a, tree_b, interesting_ids=None):
1295
1416
        object.__init__(self)
1331
1452
    def get_entry(self, file_id, tree):
1332
1453
        if not tree.has_or_had_id(file_id):
1333
1454
            return None
1334
 
        return tree.tree.inventory[file_id]
 
1455
        return tree.inventory[file_id]
1335
1456
 
1336
1457
    def get_entry_parent(self, entry):
1337
1458
        if entry is None:
1387
1508
 
1388
1509
        if cs_entry is None:
1389
1510
            return None
 
1511
 
 
1512
        cs_entry.metadata_change = self.make_exec_flag_change(id)
 
1513
 
1390
1514
        if id in self.tree_a and id in self.tree_b:
1391
1515
            a_sha1 = self.tree_a.get_file_sha1(id)
1392
1516
            b_sha1 = self.tree_b.get_file_sha1(id)
1393
1517
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1394
1518
                return cs_entry
1395
1519
 
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)
 
1520
        cs_entry.contents_change = self.make_contents_change(id)
1406
1521
        return cs_entry
1407
1522
 
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)
 
1523
    def make_exec_flag_change(self, file_id):
 
1524
        exec_flag_a = exec_flag_b = None
 
1525
        if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
 
1526
            exec_flag_a = self.tree_a.is_executable(file_id)
 
1527
 
 
1528
        if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
 
1529
            exec_flag_b = self.tree_b.is_executable(file_id)
 
1530
 
 
1531
        if exec_flag_a == exec_flag_b:
 
1532
            return None
 
1533
        return ChangeExecFlag(exec_flag_a, exec_flag_b)
 
1534
 
 
1535
    def make_contents_change(self, file_id):
 
1536
        a_contents = get_contents(self.tree_a, file_id)
 
1537
        b_contents = get_contents(self.tree_b, file_id)
1433
1538
        if a_contents == b_contents:
1434
1539
            return None
1435
1540
        return ReplaceContents(a_contents, b_contents)
1436
1541
 
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
1542
 
1449
 
    def lstat(self, full_path):
1450
 
        stat_result = None
1451
 
        if full_path is not None:
1452
 
            try:
1453
 
                stat_result = os.lstat(full_path)
1454
 
            except OSError, e:
1455
 
                if e.errno != errno.ENOENT:
1456
 
                    raise
1457
 
        return stat_result
 
1543
def get_contents(tree, file_id):
 
1544
    """Return the appropriate contents to create a copy of file_id from tree"""
 
1545
    if file_id not in tree:
 
1546
        return None
 
1547
    kind = tree.kind(file_id)
 
1548
    if kind == "file":
 
1549
        return TreeFileCreate(tree, file_id)
 
1550
    elif kind in ("directory", "root_directory"):
 
1551
        return dir_create
 
1552
    elif kind == "symlink":
 
1553
        return SymlinkCreate(tree.get_symlink_target(file_id))
 
1554
    else:
 
1555
        raise UnsupportedFiletype(kind, tree.id2path(file_id))
1458
1556
 
1459
1557
 
1460
1558
def full_path(entry, tree):
1461
 
    return os.path.join(tree.root, entry.path)
 
1559
    return pathjoin(tree.basedir, entry.path)
1462
1560
 
1463
1561
def new_delete_entry(entry, tree, inventory, delete):
1464
1562
    if entry.path == "":
1514
1612
            return None
1515
1613
        directory = self.get_dir(id)
1516
1614
        if directory == '.':
1517
 
            directory = './.'
 
1615
            directory = u'./.'
1518
1616
        if directory is None:
1519
1617
            return NULL_ID
1520
1618
        return self.get_rinventory().get(directory)