← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/changeset.py

  • Committer: Aaron Bentley
  • Date: 2005-09-21 15:33:23 UTC
  • mto: (1185.1.37)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: abentley@panoramicfeedback.com-20050921153323-5db674d572d7649d
Fixed bug in distance-from-root graph operation

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
 
 
25
16
import os.path
26
17
import errno
 
18
import patch
27
19
import stat
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
 
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
"""
35
30
 
36
31
__docformat__ = "restructuredtext"
37
32
 
38
 
 
39
33
NULL_ID = "!NULL"
40
34
 
41
 
 
42
35
class OldFailedTreeOp(Exception):
43
36
    def __init__(self):
44
37
        Exception.__init__(self, "bzr-tree-change contains files from a"
45
38
                           " previous failed merge operation.")
46
 
 
47
 
 
48
39
def invert_dict(dict):
49
40
    newdict = {}
50
41
    for (key,value) in dict.iteritems():
51
42
        newdict[value] = key
52
43
    return newdict
53
44
 
 
45
 
54
46
       
55
 
class ChangeExecFlag(object):
 
47
class ChangeUnixPermissions(object):
56
48
    """This is two-way change, suitable for file modification, creation,
57
49
    deletion"""
58
 
    def __init__(self, old_exec_flag, new_exec_flag):
59
 
        self.old_exec_flag = old_exec_flag
60
 
        self.new_exec_flag = new_exec_flag
 
50
    def __init__(self, old_mode, new_mode):
 
51
        self.old_mode = old_mode
 
52
        self.new_mode = new_mode
61
53
 
62
 
    def apply(self, filename, conflict_handler):
63
 
        from_exec_flag = self.old_exec_flag
64
 
        to_exec_flag = self.new_exec_flag
 
54
    def apply(self, filename, conflict_handler, reverse=False):
 
55
        if not reverse:
 
56
            from_mode = self.old_mode
 
57
            to_mode = self.new_mode
 
58
        else:
 
59
            from_mode = self.new_mode
 
60
            to_mode = self.old_mode
65
61
        try:
66
 
            current_exec_flag = bool(os.stat(filename).st_mode & 0111)
 
62
            current_mode = os.stat(filename).st_mode &0777
67
63
        except OSError, e:
68
64
            if e.errno == errno.ENOENT:
69
 
                if conflict_handler.missing_for_exec_flag(filename) == "skip":
 
65
                if conflict_handler.missing_for_chmod(filename) == "skip":
70
66
                    return
71
67
                else:
72
 
                    current_exec_flag = from_exec_flag
 
68
                    current_mode = from_mode
73
69
 
74
 
        if from_exec_flag is not None and current_exec_flag != from_exec_flag:
75
 
            if conflict_handler.wrong_old_exec_flag(filename,
76
 
                        from_exec_flag, current_exec_flag) != "continue":
 
70
        if from_mode is not None and current_mode != from_mode:
 
71
            if conflict_handler.wrong_old_perms(filename, from_mode, 
 
72
                                                current_mode) != "continue":
77
73
                return
78
74
 
79
 
        if to_exec_flag is not None:
80
 
            current_mode = os.stat(filename).st_mode
81
 
            if to_exec_flag:
82
 
                umask = os.umask(0)
83
 
                os.umask(umask)
84
 
                to_mode = current_mode | (0100 & ~umask)
85
 
                # Enable x-bit for others only if they can read it.
86
 
                if current_mode & 0004:
87
 
                    to_mode |= 0001 & ~umask
88
 
                if current_mode & 0040:
89
 
                    to_mode |= 0010 & ~umask
90
 
            else:
91
 
                to_mode = current_mode & ~0111
 
75
        if to_mode is not None:
92
76
            try:
93
77
                os.chmod(filename, to_mode)
94
78
            except IOError, e:
95
79
                if e.errno == errno.ENOENT:
96
 
                    conflict_handler.missing_for_exec_flag(filename)
 
80
                    conflict_handler.missing_for_chmod(filename)
97
81
 
98
82
    def __eq__(self, other):
99
 
        return (isinstance(other, ChangeExecFlag) and
100
 
                self.old_exec_flag == other.old_exec_flag and
101
 
                self.new_exec_flag == other.new_exec_flag)
 
83
        if not isinstance(other, ChangeUnixPermissions):
 
84
            return False
 
85
        elif self.old_mode != other.old_mode:
 
86
            return False
 
87
        elif self.new_mode != other.new_mode:
 
88
            return False
 
89
        else:
 
90
            return True
102
91
 
103
92
    def __ne__(self, other):
104
93
        return not (self == other)
105
94
 
106
 
 
107
 
def dir_create(filename, conflict_handler, reverse=False):
 
95
def dir_create(filename, conflict_handler, reverse):
108
96
    """Creates the directory, or deletes it if reverse is true.  Intended to be
109
97
    used with ReplaceContents.
110
98
 
129
117
        try:
130
118
            os.rmdir(filename)
131
119
        except OSError, e:
132
 
            if e.errno != errno.ENOTEMPTY:
 
120
            if e.errno != 39:
133
121
                raise
134
122
            if conflict_handler.rmdir_non_empty(filename) == "skip":
135
123
                return
136
124
            os.rmdir(filename)
137
125
 
 
126
                
 
127
            
138
128
 
139
129
class SymlinkCreate(object):
140
130
    """Creates or deletes a symlink (for use with ReplaceContents)"""
146
136
        """
147
137
        self.target = contents
148
138
 
149
 
    def __repr__(self):
150
 
        return "SymlinkCreate(%s)" % self.target
151
 
 
152
 
    def __call__(self, filename, conflict_handler, reverse=False):
 
139
    def __call__(self, filename, conflict_handler, reverse):
153
140
        """Creates or destroys the symlink.
154
141
 
155
142
        :param filename: The name of the symlink to create
178
165
    def __ne__(self, other):
179
166
        return not (self == other)
180
167
 
181
 
 
182
168
class FileCreate(object):
183
169
    """Create or delete a file (for use with ReplaceContents)"""
184
170
    def __init__(self, contents):
203
189
    def __ne__(self, other):
204
190
        return not (self == other)
205
191
 
206
 
    def __call__(self, filename, conflict_handler, reverse=False):
 
192
    def __call__(self, filename, conflict_handler, reverse):
207
193
        """Create or delete a file
208
194
 
209
195
        :param filename: The name of the file to create
235
221
                if conflict_handler.missing_for_rm(filename, undo) == "skip":
236
222
                    return
237
223
 
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=False):
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
 
 
 
224
                    
 
225
 
 
226
def reversed(sequence):
 
227
    max = len(sequence) - 1
 
228
    for i in range(len(sequence)):
 
229
        yield sequence[max - i]
303
230
 
304
231
class ReplaceContents(object):
305
232
    """A contents-replacement framework.  It allows a file/directory/symlink to
337
264
    def __ne__(self, other):
338
265
        return not (self == other)
339
266
 
340
 
    def apply(self, filename, conflict_handler):
 
267
    def apply(self, filename, conflict_handler, reverse=False):
341
268
        """Applies the FileReplacement to the specified filename
342
269
 
343
270
        :param filename: The name of the file to apply changes to
344
271
        :type filename: str
 
272
        :param reverse: If true, apply the change in reverse
 
273
        :type reverse: bool
345
274
        """
346
 
        undo = self.old_contents
347
 
        perform = self.new_contents
 
275
        if not reverse:
 
276
            undo = self.old_contents
 
277
            perform = self.new_contents
 
278
        else:
 
279
            undo = self.new_contents
 
280
            perform = self.old_contents
348
281
        mode = None
349
282
        if undo is not None:
350
283
            try:
358
291
                    return
359
292
            undo(filename, conflict_handler, reverse=True)
360
293
        if perform is not None:
361
 
            perform(filename, conflict_handler)
 
294
            perform(filename, conflict_handler, reverse=False)
362
295
            if mode is not None:
363
296
                os.chmod(filename, mode)
364
297
 
365
 
    def is_creation(self):
366
 
        return self.new_contents is not None and self.old_contents is None
367
 
 
368
 
    def is_deletion(self):
369
 
        return self.old_contents is not None and self.new_contents is None
 
298
class ApplySequence(object):
 
299
    def __init__(self, changes=None):
 
300
        self.changes = []
 
301
        if changes is not None:
 
302
            self.changes.extend(changes)
 
303
 
 
304
    def __eq__(self, other):
 
305
        if not isinstance(other, ApplySequence):
 
306
            return False
 
307
        elif len(other.changes) != len(self.changes):
 
308
            return False
 
309
        else:
 
310
            for i in range(len(self.changes)):
 
311
                if self.changes[i] != other.changes[i]:
 
312
                    return False
 
313
            return True
 
314
 
 
315
    def __ne__(self, other):
 
316
        return not (self == other)
 
317
 
 
318
    
 
319
    def apply(self, filename, conflict_handler, reverse=False):
 
320
        if not reverse:
 
321
            iter = self.changes
 
322
        else:
 
323
            iter = reversed(self.changes)
 
324
        for change in iter:
 
325
            change.apply(filename, conflict_handler, reverse)
370
326
 
371
327
 
372
328
class Diff3Merge(object):
373
 
    history_based = False
374
329
    def __init__(self, file_id, base, other):
375
330
        self.file_id = file_id
376
331
        self.base = base
377
332
        self.other = other
378
333
 
379
 
    def is_creation(self):
380
 
        return False
381
 
 
382
 
    def is_deletion(self):
383
 
        return False
384
 
 
385
334
    def __eq__(self, other):
386
335
        if not isinstance(other, Diff3Merge):
387
336
            return False
391
340
    def __ne__(self, other):
392
341
        return not (self == other)
393
342
 
394
 
    def dump_file(self, temp_dir, name, tree):
395
 
        out_path = pathjoin(temp_dir, name)
396
 
        out_file = file(out_path, "wb")
397
 
        in_file = tree.get_file(self.file_id)
398
 
        for line in in_file:
399
 
            out_file.write(line)
400
 
        return out_path
401
 
 
402
 
    def apply(self, filename, conflict_handler):
403
 
        import bzrlib.patch
404
 
        temp_dir = mkdtemp(prefix="bzr-", dir=os.path.dirname(filename))
405
 
        try:
406
 
            new_file = os.path.join(temp_dir, filename)
407
 
            base_file = self.dump_file(temp_dir, "base", self.base)
408
 
            other_file = self.dump_file(temp_dir, "other", self.other)
 
343
    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:
409
348
            base = base_file
410
349
            other = other_file
411
 
            status = bzrlib.patch.diff3(new_file, filename, base, other)
412
 
            if status == 0:
413
 
                os.chmod(new_file, os.stat(filename).st_mode)
414
 
                rename(new_file, filename)
415
 
                return
416
 
            else:
417
 
                assert(status == 1)
418
 
                def get_lines(filename):
419
 
                    my_file = file(filename, "rb")
420
 
                    lines = my_file.readlines()
421
 
                    my_file.close()
422
 
                    return lines
423
 
                base_lines = get_lines(base)
424
 
                other_lines = get_lines(other)
425
 
                conflict_handler.merge_conflict(new_file, filename, base_lines, 
426
 
                                                other_lines)
427
 
        finally:
428
 
            rmtree(temp_dir)
 
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)
429
368
 
430
369
 
431
370
def CreateDir():
436
375
    """
437
376
    return ReplaceContents(None, dir_create)
438
377
 
439
 
 
440
378
def DeleteDir():
441
379
    """Convenience function to delete a directory.
442
380
 
445
383
    """
446
384
    return ReplaceContents(dir_create, None)
447
385
 
448
 
 
449
386
def CreateFile(contents):
450
387
    """Convenience fucntion to create a file.
451
388
    
456
393
    """
457
394
    return ReplaceContents(None, FileCreate(contents))
458
395
 
459
 
 
460
396
def DeleteFile(contents):
461
397
    """Convenience fucntion to delete a file.
462
398
    
467
403
    """
468
404
    return ReplaceContents(FileCreate(contents), None)
469
405
 
470
 
 
471
 
def ReplaceFileContents(old_tree, new_tree, file_id):
 
406
def ReplaceFileContents(old_contents, new_contents):
472
407
    """Convenience fucntion to replace the contents of a file.
473
408
    
474
409
    :param old_contents: The contents of the file to replace 
478
413
    :return: A ReplaceContents that will replace the contents of a file a file 
479
414
    :rtype: `ReplaceContents`
480
415
    """
481
 
    return ReplaceContents(TreeFileCreate(old_tree, file_id), 
482
 
                           TreeFileCreate(new_tree, file_id))
483
 
 
 
416
    return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
484
417
 
485
418
def CreateSymlink(target):
486
419
    """Convenience fucntion to create a symlink.
492
425
    """
493
426
    return ReplaceContents(None, SymlinkCreate(target))
494
427
 
495
 
 
496
428
def DeleteSymlink(target):
497
429
    """Convenience fucntion to delete a symlink.
498
430
    
503
435
    """
504
436
    return ReplaceContents(SymlinkCreate(target), None)
505
437
 
506
 
 
507
438
def ChangeTarget(old_target, new_target):
508
439
    """Convenience fucntion to change the target of a symlink.
509
440
    
547
478
        msg = 'Child of !NULL is named "%s", not "./.".' % name
548
479
        InvalidEntry.__init__(self, entry, msg)
549
480
 
550
 
 
551
481
class NullIDAssigned(InvalidEntry):
552
482
    """The id !NULL was assigned to a real entry"""
553
483
    def __init__(self, entry):
559
489
        msg = '"!NULL" id assigned to a file "%s".' % entry.path
560
490
        InvalidEntry.__init__(self, entry, msg)
561
491
 
562
 
 
563
492
class ParentIDIsSelf(InvalidEntry):
564
493
    """An entry is marked as its own parent"""
565
494
    def __init__(self, entry):
572
501
            (entry.path, entry.id)
573
502
        InvalidEntry.__init__(self, entry, msg)
574
503
 
575
 
 
576
504
class ChangesetEntry(object):
577
505
    """An entry the changeset"""
578
506
    def __init__(self, id, parent, path):
597
525
        if self.id  == self.parent:
598
526
            raise ParentIDIsSelf(self)
599
527
 
600
 
    def __repr__(self):
 
528
    def __str__(self):
601
529
        return "ChangesetEntry(%s)" % self.id
602
530
 
603
 
    __str__ = __repr__
604
 
 
605
531
    def __get_dir(self):
606
532
        if self.path is None:
607
533
            return None
608
534
        return os.path.dirname(self.path)
609
535
 
610
536
    def __set_dir(self, dir):
611
 
        self.path = pathjoin(dir, os.path.basename(self.path))
 
537
        self.path = os.path.join(dir, os.path.basename(self.path))
612
538
 
613
539
    dir = property(__get_dir, __set_dir)
614
540
    
618
544
        return os.path.basename(self.path)
619
545
 
620
546
    def __set_name(self, name):
621
 
        self.path = pathjoin(os.path.dirname(self.path), name)
 
547
        self.path = os.path.join(os.path.dirname(self.path), name)
622
548
 
623
549
    name = property(__get_name, __set_name)
624
550
 
628
554
        return os.path.dirname(self.new_path)
629
555
 
630
556
    def __set_new_dir(self, dir):
631
 
        self.new_path = pathjoin(dir, os.path.basename(self.new_path))
 
557
        self.new_path = os.path.join(dir, os.path.basename(self.new_path))
632
558
 
633
559
    new_dir = property(__get_new_dir, __set_new_dir)
634
560
 
638
564
        return os.path.basename(self.new_path)
639
565
 
640
566
    def __set_new_name(self, name):
641
 
        self.new_path = pathjoin(os.path.dirname(self.new_path), name)
 
567
        self.new_path = os.path.join(os.path.dirname(self.new_path), name)
642
568
 
643
569
    new_name = property(__get_new_name, __set_new_name)
644
570
 
647
573
 
648
574
        :rtype: bool
649
575
        """
 
576
 
650
577
        return (self.parent != self.new_parent or self.name != self.new_name)
651
578
 
652
 
    def is_deletion(self, reverse=False):
 
579
    def is_deletion(self, reverse):
653
580
        """Return true if applying the entry would delete a file/directory.
654
581
 
655
582
        :param reverse: if true, the changeset is being applied in reverse
656
583
        :rtype: bool
657
584
        """
658
 
        return self.is_creation(not reverse)
 
585
        return ((self.new_parent is None and not reverse) or 
 
586
                (self.parent is None and reverse))
659
587
 
660
 
    def is_creation(self, reverse=False):
 
588
    def is_creation(self, reverse):
661
589
        """Return true if applying the entry would create a file/directory.
662
590
 
663
591
        :param reverse: if true, the changeset is being applied in reverse
664
592
        :rtype: bool
665
593
        """
666
 
        if self.contents_change is None:
667
 
            return False
668
 
        if reverse:
669
 
            return self.contents_change.is_deletion()
670
 
        else:
671
 
            return self.contents_change.is_creation()
 
594
        return ((self.parent is None and not reverse) or 
 
595
                (self.new_parent is None and reverse))
672
596
 
673
597
    def is_creation_or_deletion(self):
674
598
        """Return true if applying the entry would create or delete a 
676
600
 
677
601
        :rtype: bool
678
602
        """
679
 
        return self.is_creation() or self.is_deletion()
 
603
        return self.parent is None or self.new_parent is None
680
604
 
681
605
    def get_cset_path(self, mod=False):
682
606
        """Determine the path of the entry according to the changeset.
702
626
                return None
703
627
            return self.path
704
628
 
705
 
    def summarize_name(self):
 
629
    def summarize_name(self, reverse=False):
706
630
        """Produce a one-line summary of the filename.  Indicates renames as
707
631
        old => new, indicates creation as None => new, indicates deletion as
708
632
        old => None.
709
633
 
 
634
        :param changeset: The changeset to get paths from
 
635
        :type changeset: `Changeset`
 
636
        :param reverse: If true, reverse the names in the output
 
637
        :type reverse: bool
710
638
        :rtype: str
711
639
        """
712
640
        orig_path = self.get_cset_path(False)
713
641
        mod_path = self.get_cset_path(True)
714
 
        if orig_path and orig_path.startswith('./'):
 
642
        if orig_path is not None:
715
643
            orig_path = orig_path[2:]
716
 
        if mod_path and mod_path.startswith('./'):
 
644
        if mod_path is not None:
717
645
            mod_path = mod_path[2:]
718
646
        if orig_path == mod_path:
719
647
            return orig_path
720
648
        else:
721
 
            return "%s => %s" % (orig_path, mod_path)
722
 
 
723
 
    def get_new_path(self, id_map, changeset):
 
649
            if not reverse:
 
650
                return "%s => %s" % (orig_path, mod_path)
 
651
            else:
 
652
                return "%s => %s" % (mod_path, orig_path)
 
653
 
 
654
 
 
655
    def get_new_path(self, id_map, changeset, reverse=False):
724
656
        """Determine the full pathname to rename to
725
657
 
726
658
        :param id_map: The map of ids to filenames for the tree
727
659
        :type id_map: Dictionary
728
660
        :param changeset: The changeset to get data from
729
661
        :type changeset: `Changeset`
 
662
        :param reverse: If true, we're applying the changeset in reverse
 
663
        :type reverse: bool
730
664
        :rtype: str
731
665
        """
732
 
        mutter("Finding new path for %s", self.summarize_name())
733
 
        parent = self.new_parent
734
 
        to_dir = self.new_dir
735
 
        from_dir = self.dir
736
 
        to_name = self.new_name
737
 
        from_name = self.name
 
666
        mutter("Finding new path for %s" % self.summarize_name())
 
667
        if reverse:
 
668
            parent = self.parent
 
669
            to_dir = self.dir
 
670
            from_dir = self.new_dir
 
671
            to_name = self.name
 
672
            from_name = self.new_name
 
673
        else:
 
674
            parent = self.new_parent
 
675
            to_dir = self.new_dir
 
676
            from_dir = self.dir
 
677
            to_name = self.new_name
 
678
            from_name = self.name
738
679
 
739
680
        if to_name is None:
740
681
            return None
741
682
 
742
683
        if parent == NULL_ID or parent is None:
743
 
            if to_name != u'.':
 
684
            if to_name != '.':
744
685
                raise SourceRootHasName(self, to_name)
745
686
            else:
746
 
                return u'.'
747
 
        parent_entry = changeset.entries.get(parent)
748
 
        if parent_entry is None:
 
687
                return '.'
 
688
        if from_dir == to_dir:
749
689
            dir = os.path.dirname(id_map[self.id])
750
690
        else:
751
 
            mutter("path, new_path: %r %r", self.path, self.new_path)
752
 
            dir = parent_entry.get_new_path(id_map, changeset)
 
691
            mutter("path, new_path: %r %r" % (self.path, self.new_path))
 
692
            parent_entry = changeset.entries[parent]
 
693
            dir = parent_entry.get_new_path(id_map, changeset, reverse)
753
694
        if from_name == to_name:
754
695
            name = os.path.basename(id_map[self.id])
755
696
        else:
756
697
            name = to_name
757
698
            assert(from_name is None or from_name == os.path.basename(id_map[self.id]))
758
 
        return pathjoin(dir, name)
 
699
        return os.path.join(dir, name)
759
700
 
760
701
    def is_boring(self):
761
702
        """Determines whether the entry does nothing
774
715
        else:
775
716
            return True
776
717
 
777
 
    def apply(self, filename, conflict_handler):
 
718
    def apply(self, filename, conflict_handler, reverse=False):
778
719
        """Applies the file content and/or metadata changes.
779
720
 
780
721
        :param filename: the filename of the entry
781
722
        :type filename: str
 
723
        :param reverse: If true, apply the changes in reverse
 
724
        :type reverse: bool
782
725
        """
783
 
        if self.is_deletion() and self.metadata_change is not None:
784
 
            self.metadata_change.apply(filename, conflict_handler)
 
726
        if self.is_deletion(reverse) and self.metadata_change is not None:
 
727
            self.metadata_change.apply(filename, conflict_handler, reverse)
785
728
        if self.contents_change is not None:
786
 
            self.contents_change.apply(filename, conflict_handler)
787
 
        if not self.is_deletion() and self.metadata_change is not None:
788
 
            self.metadata_change.apply(filename, conflict_handler)
789
 
 
 
729
            self.contents_change.apply(filename, conflict_handler, reverse)
 
730
        if not self.is_deletion(reverse) and self.metadata_change is not None:
 
731
            self.metadata_change.apply(filename, conflict_handler, reverse)
790
732
 
791
733
class IDPresent(Exception):
792
734
    def __init__(self, id):
795
737
        Exception.__init__(self, msg)
796
738
        self.id = id
797
739
 
798
 
 
799
740
class Changeset(object):
800
741
    """A set of changes to apply"""
801
742
    def __init__(self):
807
748
            raise IDPresent(entry.id)
808
749
        self.entries[entry.id] = entry
809
750
 
 
751
def my_sort(sequence, key, reverse=False):
 
752
    """A sort function that supports supplying a key for comparison
 
753
    
 
754
    :param sequence: The sequence to sort
 
755
    :param key: A callable object that returns the values to be compared
 
756
    :param reverse: If true, sort in reverse order
 
757
    :type reverse: bool
 
758
    """
 
759
    def cmp_by_key(entry_a, entry_b):
 
760
        if reverse:
 
761
            tmp=entry_a
 
762
            entry_a = entry_b
 
763
            entry_b = tmp
 
764
        return cmp(key(entry_a), key(entry_b))
 
765
    sequence.sort(cmp_by_key)
810
766
 
811
 
def get_rename_entries(changeset, inventory):
 
767
def get_rename_entries(changeset, inventory, reverse):
812
768
    """Return a list of entries that will be renamed.  Entries are sorted from
813
769
    longest to shortest source path and from shortest to longest target path.
814
770
 
816
772
    :type changeset: `Changeset`
817
773
    :param inventory: The source of current tree paths for the given ids
818
774
    :type inventory: Dictionary
 
775
    :param reverse: If true, the changeset is being applied in reverse
 
776
    :type reverse: bool
819
777
    :return: source entries and target entries as a tuple
820
778
    :rtype: (List, List)
821
779
    """
822
780
    source_entries = [x for x in changeset.entries.itervalues() 
823
 
                      if x.needs_rename() or x.is_creation_or_deletion()]
 
781
                      if x.needs_rename()]
824
782
    # these are done from longest path to shortest, to avoid deleting a
825
783
    # parent before its children are deleted/renamed 
826
784
    def longest_to_shortest(entry):
829
787
            return 0
830
788
        else:
831
789
            return len(path)
832
 
    source_entries.sort(None, longest_to_shortest, True)
 
790
    my_sort(source_entries, longest_to_shortest, reverse=True)
833
791
 
834
792
    target_entries = source_entries[:]
835
793
    # These are done from shortest to longest path, to avoid creating a
836
794
    # child before its parent has been created/renamed
837
795
    def shortest_to_longest(entry):
838
 
        path = entry.get_new_path(inventory, changeset)
 
796
        path = entry.get_new_path(inventory, changeset, reverse)
839
797
        if path is None:
840
798
            return 0
841
799
        else:
842
800
            return len(path)
843
 
    target_entries.sort(None, shortest_to_longest)
 
801
    my_sort(target_entries, shortest_to_longest)
844
802
    return (source_entries, target_entries)
845
803
 
846
 
 
847
804
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir, 
848
 
                          conflict_handler):
 
805
                          conflict_handler, reverse):
849
806
    """Delete and rename entries as appropriate.  Entries are renamed to temp
850
807
    names.  A map of id -> temp name (or None, for deletions) is returned.
851
808
 
855
812
    :type inventory: Dictionary
856
813
    :param dir: The directory to apply changes to
857
814
    :type dir: str
 
815
    :param reverse: Apply changes in reverse
 
816
    :type reverse: bool
858
817
    :return: a mapping of id to temporary name
859
818
    :rtype: Dictionary
860
819
    """
861
820
    temp_name = {}
862
821
    for i in range(len(source_entries)):
863
822
        entry = source_entries[i]
864
 
        if entry.is_deletion():
865
 
            path = pathjoin(dir, inventory[entry.id])
866
 
            entry.apply(path, conflict_handler)
 
823
        if entry.is_deletion(reverse):
 
824
            path = os.path.join(dir, inventory[entry.id])
 
825
            entry.apply(path, conflict_handler, reverse)
867
826
            temp_name[entry.id] = None
868
827
 
869
 
        elif entry.needs_rename():
870
 
            if entry.is_creation():
871
 
                continue
872
 
            to_name = pathjoin(temp_dir, str(i))
 
828
        else:
 
829
            to_name = os.path.join(temp_dir, str(i))
873
830
            src_path = inventory.get(entry.id)
874
831
            if src_path is not None:
875
 
                src_path = pathjoin(dir, src_path)
 
832
                src_path = os.path.join(dir, src_path)
876
833
                try:
877
 
                    rename(src_path, to_name)
 
834
                    os.rename(src_path, to_name)
878
835
                    temp_name[entry.id] = to_name
879
836
                except OSError, e:
880
837
                    if e.errno != errno.ENOENT:
881
838
                        raise
882
 
                    if conflict_handler.missing_for_rename(src_path, to_name) \
883
 
                        == "skip":
 
839
                    if conflict_handler.missing_for_rename(src_path) == "skip":
884
840
                        continue
885
841
 
886
842
    return temp_name
887
843
 
888
844
 
889
845
def rename_to_new_create(changed_inventory, target_entries, inventory, 
890
 
                         changeset, dir, conflict_handler):
 
846
                         changeset, dir, conflict_handler, reverse):
891
847
    """Rename entries with temp names to their final names, create new files.
892
848
 
893
849
    :param changed_inventory: A mapping of id to temporary name
898
854
    :type changeset: `Changeset`
899
855
    :param dir: The directory to apply changes to
900
856
    :type dir: str
 
857
    :param reverse: If true, apply changes in reverse
 
858
    :type reverse: bool
901
859
    """
902
860
    for entry in target_entries:
903
 
        new_tree_path = entry.get_new_path(inventory, changeset)
 
861
        new_tree_path = entry.get_new_path(inventory, changeset, reverse)
904
862
        if new_tree_path is None:
905
863
            continue
906
 
        new_path = pathjoin(dir, new_tree_path)
 
864
        new_path = os.path.join(dir, new_tree_path)
907
865
        old_path = changed_inventory.get(entry.id)
908
 
        if bzrlib.osutils.lexists(new_path):
 
866
        if os.path.exists(new_path):
909
867
            if conflict_handler.target_exists(entry, new_path, old_path) == \
910
868
                "skip":
911
869
                continue
912
 
        if entry.is_creation():
913
 
            entry.apply(new_path, conflict_handler)
 
870
        if entry.is_creation(reverse):
 
871
            entry.apply(new_path, conflict_handler, reverse)
914
872
            changed_inventory[entry.id] = new_tree_path
915
 
        elif entry.needs_rename():
916
 
            if entry.is_deletion():
917
 
                continue
 
873
        else:
918
874
            if old_path is None:
919
875
                continue
920
876
            try:
921
 
                mutter('rename %s to final name %s', old_path, new_path)
922
 
                rename(old_path, new_path)
 
877
                os.rename(old_path, new_path)
923
878
                changed_inventory[entry.id] = new_tree_path
924
879
            except OSError, e:
925
 
                raise BzrCheckError('failed to rename %s to %s for changeset entry %s: %s'
926
 
                        % (old_path, new_path, entry, e))
927
 
 
 
880
                raise Exception ("%s is missing" % new_path)
928
881
 
929
882
class TargetExists(Exception):
930
883
    def __init__(self, entry, target):
933
886
        self.entry = entry
934
887
        self.target = target
935
888
 
936
 
 
937
889
class RenameConflict(Exception):
938
890
    def __init__(self, id, this_name, base_name, other_name):
939
891
        msg = """Trees all have different names for a file
946
898
        self.base_name = base_name
947
899
        self_other_name = other_name
948
900
 
949
 
 
950
901
class MoveConflict(Exception):
951
902
    def __init__(self, id, this_parent, base_parent, other_parent):
952
903
        msg = """The file is in different directories in every tree
959
910
        self.base_parent = base_parent
960
911
        self_other_parent = other_parent
961
912
 
962
 
 
963
913
class MergeConflict(Exception):
964
914
    def __init__(self, this_path):
965
915
        Exception.__init__(self, "Conflict applying changes to %s" % this_path)
966
916
        self.this_path = this_path
967
917
 
 
918
class MergePermissionConflict(Exception):
 
919
    def __init__(self, this_path, base_path, other_path):
 
920
        this_perms = os.stat(this_path).st_mode & 0755
 
921
        base_perms = os.stat(base_path).st_mode & 0755
 
922
        other_perms = os.stat(other_path).st_mode & 0755
 
923
        msg = """Conflicting permission for %s
 
924
this: %o
 
925
base: %o
 
926
other: %o
 
927
        """ % (this_path, this_perms, base_perms, other_perms)
 
928
        self.this_path = this_path
 
929
        self.base_path = base_path
 
930
        self.other_path = other_path
 
931
        Exception.__init__(self, msg)
968
932
 
969
933
class WrongOldContents(Exception):
970
934
    def __init__(self, filename):
972
936
        self.filename = filename
973
937
        Exception.__init__(self, msg)
974
938
 
975
 
 
976
 
class WrongOldExecFlag(Exception):
977
 
    def __init__(self, filename, old_exec_flag, new_exec_flag):
978
 
        msg = "Executable flag missmatch on %s:\n" \
979
 
        "Expected %s, got %s." % (filename, old_exec_flag, new_exec_flag)
 
939
class WrongOldPermissions(Exception):
 
940
    def __init__(self, filename, old_perms, new_perms):
 
941
        msg = "Permission missmatch on %s:\n" \
 
942
        "Expected 0%o, got 0%o." % (filename, old_perms, new_perms)
980
943
        self.filename = filename
981
944
        Exception.__init__(self, msg)
982
945
 
983
 
 
984
946
class RemoveContentsConflict(Exception):
985
947
    def __init__(self, filename):
986
948
        msg = "Conflict deleting %s, which has different contents in BASE"\
988
950
        self.filename = filename
989
951
        Exception.__init__(self, msg)
990
952
 
991
 
 
992
953
class DeletingNonEmptyDirectory(Exception):
993
954
    def __init__(self, filename):
994
955
        msg = "Trying to remove dir %s while it still had files" % filename
1002
963
        Exception.__init__(self, msg)
1003
964
        self.filename = filename
1004
965
 
1005
 
 
1006
 
class MissingForSetExec(Exception):
 
966
class MissingPermsFile(Exception):
1007
967
    def __init__(self, filename):
1008
968
        msg = "Attempt to change permissions on  %s, which does not exist" %\
1009
969
            filename
1010
970
        Exception.__init__(self, msg)
1011
971
        self.filename = filename
1012
972
 
1013
 
 
1014
973
class MissingForRm(Exception):
1015
974
    def __init__(self, filename):
1016
975
        msg = "Attempt to remove missing path %s" % filename
1019
978
 
1020
979
 
1021
980
class MissingForRename(Exception):
1022
 
    def __init__(self, filename, to_path):
1023
 
        msg = "Attempt to move missing path %s to %s" % (filename, to_path)
 
981
    def __init__(self, filename):
 
982
        msg = "Attempt to move missing path %s" % (filename)
1024
983
        Exception.__init__(self, msg)
1025
984
        self.filename = filename
1026
985
 
1027
 
 
1028
986
class NewContentsConflict(Exception):
1029
987
    def __init__(self, filename):
1030
988
        msg = "Conflicting contents for new file %s" % (filename)
1031
989
        Exception.__init__(self, msg)
1032
990
 
1033
991
 
1034
 
class WeaveMergeConflict(Exception):
1035
 
    def __init__(self, filename):
1036
 
        msg = "Conflicting contents for file %s" % (filename)
1037
 
        Exception.__init__(self, msg)
1038
 
 
1039
 
 
1040
 
class ThreewayContentsConflict(Exception):
1041
 
    def __init__(self, filename):
1042
 
        msg = "Conflicting contents for file %s" % (filename)
1043
 
        Exception.__init__(self, msg)
1044
 
 
1045
 
 
1046
992
class MissingForMerge(Exception):
1047
993
    def __init__(self, filename):
1048
994
        msg = "The file %s was modified, but does not exist in this tree"\
1080
1026
        os.unlink(new_file)
1081
1027
        raise MergeConflict(this_path)
1082
1028
 
 
1029
    def permission_conflict(self, this_path, base_path, other_path):
 
1030
        raise MergePermissionConflict(this_path, base_path, other_path)
 
1031
 
1083
1032
    def wrong_old_contents(self, filename, expected_contents):
1084
1033
        raise WrongOldContents(filename)
1085
1034
 
1086
1035
    def rem_contents_conflict(self, filename, this_contents, base_contents):
1087
1036
        raise RemoveContentsConflict(filename)
1088
1037
 
1089
 
    def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
1090
 
        raise WrongOldExecFlag(filename, old_exec_flag, new_exec_flag)
 
1038
    def wrong_old_perms(self, filename, old_perms, new_perms):
 
1039
        raise WrongOldPermissions(filename, old_perms, new_perms)
1091
1040
 
1092
1041
    def rmdir_non_empty(self, filename):
1093
1042
        raise DeletingNonEmptyDirectory(filename)
1098
1047
    def patch_target_missing(self, filename, contents):
1099
1048
        raise PatchTargetMissing(filename)
1100
1049
 
1101
 
    def missing_for_exec_flag(self, filename):
1102
 
        raise MissingForExecFlag(filename)
 
1050
    def missing_for_chmod(self, filename):
 
1051
        raise MissingPermsFile(filename)
1103
1052
 
1104
1053
    def missing_for_rm(self, filename, change):
1105
1054
        raise MissingForRm(filename)
1106
1055
 
1107
 
    def missing_for_rename(self, filename, to_path):
1108
 
        raise MissingForRename(filename, to_path)
 
1056
    def missing_for_rename(self, filename):
 
1057
        raise MissingForRename(filename)
1109
1058
 
1110
1059
    def missing_for_merge(self, file_id, other_path):
1111
1060
        raise MissingForMerge(other_path)
1113
1062
    def new_contents_conflict(self, filename, other_contents):
1114
1063
        raise NewContentsConflict(filename)
1115
1064
 
1116
 
    def weave_merge_conflict(self, filename, weave, other_i, out_file):
1117
 
        raise WeaveMergeConflict(filename)
1118
 
 
1119
 
    def threeway_contents_conflict(self, filename, this_contents,
1120
 
                                   base_contents, other_contents):
1121
 
        raise ThreewayContentsConflict(filename)
1122
 
 
1123
1065
    def finalize(self):
1124
1066
        pass
1125
1067
 
1126
 
 
1127
 
def apply_changeset(changeset, inventory, dir, conflict_handler=None):
 
1068
def apply_changeset(changeset, inventory, dir, conflict_handler=None, 
 
1069
                    reverse=False):
1128
1070
    """Apply a changeset to a directory.
1129
1071
 
1130
1072
    :param changeset: The changes to perform
1133
1075
    :type inventory: Dictionary
1134
1076
    :param dir: The path of the directory to apply the changes to
1135
1077
    :type dir: str
 
1078
    :param reverse: If true, apply the changes in reverse
 
1079
    :type reverse: bool
1136
1080
    :return: The mapping of the changed entries
1137
1081
    :rtype: Dictionary
1138
1082
    """
1139
1083
    if conflict_handler is None:
1140
1084
        conflict_handler = ExceptionConflictHandler()
1141
 
    temp_dir = pathjoin(dir, "bzr-tree-change")
 
1085
    temp_dir = os.path.join(dir, "bzr-tree-change")
1142
1086
    try:
1143
1087
        os.mkdir(temp_dir)
1144
1088
    except OSError, e:
1154
1098
    
1155
1099
    #apply changes that don't affect filenames
1156
1100
    for entry in changeset.entries.itervalues():
1157
 
        if not entry.is_creation_or_deletion() and not entry.is_boring():
1158
 
            if entry.id not in inventory:
1159
 
                warning("entry {%s} no longer present, can't be updated",
1160
 
                        entry.id)
1161
 
                continue
1162
 
            path = pathjoin(dir, inventory[entry.id])
1163
 
            entry.apply(path, conflict_handler)
 
1101
        if not entry.is_creation_or_deletion():
 
1102
            path = os.path.join(dir, inventory[entry.id])
 
1103
            entry.apply(path, conflict_handler, reverse)
1164
1104
 
1165
1105
    # Apply renames in stages, to minimize conflicts:
1166
1106
    # Only files whose name or parent change are interesting, because their
1167
1107
    # target name may exist in the source tree.  If a directory's name changes,
1168
1108
    # that doesn't make its children interesting.
1169
 
    (source_entries, target_entries) = get_rename_entries(changeset, inventory)
 
1109
    (source_entries, target_entries) = get_rename_entries(changeset, inventory,
 
1110
                                                          reverse)
1170
1111
 
1171
1112
    changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
1172
 
                                              temp_dir, conflict_handler)
 
1113
                                              temp_dir, conflict_handler,
 
1114
                                              reverse)
1173
1115
 
1174
1116
    rename_to_new_create(changed_inventory, target_entries, inventory,
1175
 
                         changeset, dir, conflict_handler)
 
1117
                         changeset, dir, conflict_handler, reverse)
1176
1118
    os.rmdir(temp_dir)
1177
1119
    return changed_inventory
1178
1120
 
1179
1121
 
 
1122
def apply_changeset_tree(cset, tree, reverse=False):
 
1123
    r_inventory = {}
 
1124
    for entry in tree.source_inventory().itervalues():
 
1125
        inventory[entry.id] = entry.path
 
1126
    new_inventory = apply_changeset(cset, r_inventory, tree.root,
 
1127
                                    reverse=reverse)
 
1128
    new_entries, remove_entries = \
 
1129
        get_inventory_change(inventory, new_inventory, cset, reverse)
 
1130
    tree.update_source_inventory(new_entries, remove_entries)
 
1131
 
 
1132
 
 
1133
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
 
1134
    new_entries = {}
 
1135
    remove_entries = []
 
1136
    for entry in cset.entries.itervalues():
 
1137
        if entry.needs_rename():
 
1138
            new_path = entry.get_new_path(inventory, cset)
 
1139
            if new_path is None:
 
1140
                remove_entries.append(entry.id)
 
1141
            else:
 
1142
                new_entries[new_path] = entry.id
 
1143
    return new_entries, remove_entries
 
1144
 
 
1145
 
1180
1146
def print_changeset(cset):
1181
1147
    """Print all non-boring changeset entries
1182
1148
    
1189
1155
        print entry.id
1190
1156
        print entry.summarize_name(cset)
1191
1157
 
1192
 
 
1193
 
class UnsupportedFiletype(Exception):
1194
 
    def __init__(self, kind, full_path):
1195
 
        msg = "The file \"%s\" is a %s, which is not a supported filetype." \
1196
 
            % (full_path, kind)
 
1158
class CompositionFailure(Exception):
 
1159
    def __init__(self, old_entry, new_entry, problem):
 
1160
        msg = "Unable to conpose entries.\n %s" % problem
 
1161
        Exception.__init__(self, msg)
 
1162
 
 
1163
class IDMismatch(CompositionFailure):
 
1164
    def __init__(self, old_entry, new_entry):
 
1165
        problem = "Attempt to compose entries with different ids: %s and %s" %\
 
1166
            (old_entry.id, new_entry.id)
 
1167
        CompositionFailure.__init__(self, old_entry, new_entry, problem)
 
1168
 
 
1169
def compose_changesets(old_cset, new_cset):
 
1170
    """Combine two changesets into one.  This works well for exact patching.
 
1171
    Otherwise, not so well.
 
1172
 
 
1173
    :param old_cset: The first changeset that would be applied
 
1174
    :type old_cset: `Changeset`
 
1175
    :param new_cset: The second changeset that would be applied
 
1176
    :type new_cset: `Changeset`
 
1177
    :return: A changeset that combines the changes in both changesets
 
1178
    :rtype: `Changeset`
 
1179
    """
 
1180
    composed = Changeset()
 
1181
    for old_entry in old_cset.entries.itervalues():
 
1182
        new_entry = new_cset.entries.get(old_entry.id)
 
1183
        if new_entry is None:
 
1184
            composed.add_entry(old_entry)
 
1185
        else:
 
1186
            composed_entry = compose_entries(old_entry, new_entry)
 
1187
            if composed_entry.parent is not None or\
 
1188
                composed_entry.new_parent is not None:
 
1189
                composed.add_entry(composed_entry)
 
1190
    for new_entry in new_cset.entries.itervalues():
 
1191
        if not old_cset.entries.has_key(new_entry.id):
 
1192
            composed.add_entry(new_entry)
 
1193
    return composed
 
1194
 
 
1195
def compose_entries(old_entry, new_entry):
 
1196
    """Combine two entries into one.
 
1197
 
 
1198
    :param old_entry: The first entry that would be applied
 
1199
    :type old_entry: ChangesetEntry
 
1200
    :param old_entry: The second entry that would be applied
 
1201
    :type old_entry: ChangesetEntry
 
1202
    :return: A changeset entry combining both entries
 
1203
    :rtype: `ChangesetEntry`
 
1204
    """
 
1205
    if old_entry.id != new_entry.id:
 
1206
        raise IDMismatch(old_entry, new_entry)
 
1207
    output = ChangesetEntry(old_entry.id, old_entry.parent, old_entry.path)
 
1208
 
 
1209
    if (old_entry.parent != old_entry.new_parent or 
 
1210
        new_entry.parent != new_entry.new_parent):
 
1211
        output.new_parent = new_entry.new_parent
 
1212
 
 
1213
    if (old_entry.path != old_entry.new_path or 
 
1214
        new_entry.path != new_entry.new_path):
 
1215
        output.new_path = new_entry.new_path
 
1216
 
 
1217
    output.contents_change = compose_contents(old_entry, new_entry)
 
1218
    output.metadata_change = compose_metadata(old_entry, new_entry)
 
1219
    return output
 
1220
 
 
1221
def compose_contents(old_entry, new_entry):
 
1222
    """Combine the contents of two changeset entries.  Entries are combined
 
1223
    intelligently where possible, but the fallback behavior returns an 
 
1224
    ApplySequence.
 
1225
 
 
1226
    :param old_entry: The first entry that would be applied
 
1227
    :type old_entry: `ChangesetEntry`
 
1228
    :param new_entry: The second entry that would be applied
 
1229
    :type new_entry: `ChangesetEntry`
 
1230
    :return: A combined contents change
 
1231
    :rtype: anything supporting the apply(reverse=False) method
 
1232
    """
 
1233
    old_contents = old_entry.contents_change
 
1234
    new_contents = new_entry.contents_change
 
1235
    if old_entry.contents_change is None:
 
1236
        return new_entry.contents_change
 
1237
    elif new_entry.contents_change is None:
 
1238
        return old_entry.contents_change
 
1239
    elif isinstance(old_contents, ReplaceContents) and \
 
1240
        isinstance(new_contents, ReplaceContents):
 
1241
        if old_contents.old_contents == new_contents.new_contents:
 
1242
            return None
 
1243
        else:
 
1244
            return ReplaceContents(old_contents.old_contents,
 
1245
                                   new_contents.new_contents)
 
1246
    elif isinstance(old_contents, ApplySequence):
 
1247
        output = ApplySequence(old_contents.changes)
 
1248
        if isinstance(new_contents, ApplySequence):
 
1249
            output.changes.extend(new_contents.changes)
 
1250
        else:
 
1251
            output.changes.append(new_contents)
 
1252
        return output
 
1253
    elif isinstance(new_contents, ApplySequence):
 
1254
        output = ApplySequence((old_contents.changes,))
 
1255
        output.extend(new_contents.changes)
 
1256
        return output
 
1257
    else:
 
1258
        return ApplySequence((old_contents, new_contents))
 
1259
 
 
1260
def compose_metadata(old_entry, new_entry):
 
1261
    old_meta = old_entry.metadata_change
 
1262
    new_meta = new_entry.metadata_change
 
1263
    if old_meta is None:
 
1264
        return new_meta
 
1265
    elif new_meta is None:
 
1266
        return old_meta
 
1267
    elif isinstance(old_meta, ChangeUnixPermissions) and \
 
1268
        isinstance(new_meta, ChangeUnixPermissions):
 
1269
        return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
 
1270
    else:
 
1271
        return ApplySequence(old_meta, new_meta)
 
1272
 
 
1273
 
 
1274
def changeset_is_null(changeset):
 
1275
    for entry in changeset.entries.itervalues():
 
1276
        if not entry.is_boring():
 
1277
            return False
 
1278
    return True
 
1279
 
 
1280
class UnsuppportedFiletype(Exception):
 
1281
    def __init__(self, full_path, stat_result):
 
1282
        msg = "The file \"%s\" is not a supported filetype." % full_path
1197
1283
        Exception.__init__(self, msg)
1198
1284
        self.full_path = full_path
1199
 
        self.kind = kind
1200
 
 
 
1285
        self.stat_result = stat_result
1201
1286
 
1202
1287
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1203
1288
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1204
1289
 
1205
 
 
1206
1290
class ChangesetGenerator(object):
1207
1291
    def __init__(self, tree_a, tree_b, interesting_ids=None):
1208
1292
        object.__init__(self)
1244
1328
    def get_entry(self, file_id, tree):
1245
1329
        if not tree.has_or_had_id(file_id):
1246
1330
            return None
1247
 
        return tree.inventory[file_id]
 
1331
        return tree.tree.inventory[file_id]
1248
1332
 
1249
1333
    def get_entry_parent(self, entry):
1250
1334
        if entry is None:
1293
1377
            return self.make_entry(id, only_interesting=False)
1294
1378
        else:
1295
1379
            return cs_entry
 
1380
        
1296
1381
 
1297
1382
    def make_entry(self, id, only_interesting=True):
1298
1383
        cs_entry = self.make_basic_entry(id, only_interesting)
1299
1384
 
1300
1385
        if cs_entry is None:
1301
1386
            return None
1302
 
 
1303
 
        cs_entry.metadata_change = self.make_exec_flag_change(id)
1304
 
 
1305
1387
        if id in self.tree_a and id in self.tree_b:
1306
1388
            a_sha1 = self.tree_a.get_file_sha1(id)
1307
1389
            b_sha1 = self.tree_b.get_file_sha1(id)
1308
1390
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1309
1391
                return cs_entry
1310
1392
 
1311
 
        cs_entry.contents_change = self.make_contents_change(id)
 
1393
        full_path_a = self.tree_a.readonly_path(id)
 
1394
        full_path_b = self.tree_b.readonly_path(id)
 
1395
        stat_a = self.lstat(full_path_a)
 
1396
        stat_b = self.lstat(full_path_b)
 
1397
        
 
1398
        cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
 
1399
        cs_entry.contents_change = self.make_contents_change(full_path_a,
 
1400
                                                             stat_a, 
 
1401
                                                             full_path_b, 
 
1402
                                                             stat_b)
1312
1403
        return cs_entry
1313
1404
 
1314
 
    def make_exec_flag_change(self, file_id):
1315
 
        exec_flag_a = exec_flag_b = None
1316
 
        if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
1317
 
            exec_flag_a = self.tree_a.is_executable(file_id)
1318
 
 
1319
 
        if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
1320
 
            exec_flag_b = self.tree_b.is_executable(file_id)
1321
 
 
1322
 
        if exec_flag_a == exec_flag_b:
1323
 
            return None
1324
 
        return ChangeExecFlag(exec_flag_a, exec_flag_b)
1325
 
 
1326
 
    def make_contents_change(self, file_id):
1327
 
        a_contents = get_contents(self.tree_a, file_id)
1328
 
        b_contents = get_contents(self.tree_b, file_id)
 
1405
    def make_mode_change(self, stat_a, stat_b):
 
1406
        mode_a = None
 
1407
        if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
 
1408
            mode_a = stat_a.st_mode & 0777
 
1409
        mode_b = None
 
1410
        if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
 
1411
            mode_b = stat_b.st_mode & 0777
 
1412
        if mode_a == mode_b:
 
1413
            return None
 
1414
        return ChangeUnixPermissions(mode_a, mode_b)
 
1415
 
 
1416
    def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
 
1417
        if stat_a is None and stat_b is None:
 
1418
            return None
 
1419
        if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
 
1420
            stat.S_ISDIR(stat_b.st_mode):
 
1421
            return None
 
1422
        if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
 
1423
            stat.S_ISREG(stat_b.st_mode):
 
1424
            if stat_a.st_ino == stat_b.st_ino and \
 
1425
                stat_a.st_dev == stat_b.st_dev:
 
1426
                return None
 
1427
 
 
1428
        a_contents = self.get_contents(stat_a, full_path_a)
 
1429
        b_contents = self.get_contents(stat_b, full_path_b)
1329
1430
        if a_contents == b_contents:
1330
1431
            return None
1331
1432
        return ReplaceContents(a_contents, b_contents)
1332
1433
 
 
1434
    def get_contents(self, stat_result, full_path):
 
1435
        if stat_result is None:
 
1436
            return None
 
1437
        elif stat.S_ISREG(stat_result.st_mode):
 
1438
            return FileCreate(file(full_path, "rb").read())
 
1439
        elif stat.S_ISDIR(stat_result.st_mode):
 
1440
            return dir_create
 
1441
        elif stat.S_ISLNK(stat_result.st_mode):
 
1442
            return SymlinkCreate(os.readlink(full_path))
 
1443
        else:
 
1444
            raise UnsupportedFiletype(full_path, stat_result)
1333
1445
 
1334
 
def get_contents(tree, file_id):
1335
 
    """Return the appropriate contents to create a copy of file_id from tree"""
1336
 
    if file_id not in tree:
1337
 
        return None
1338
 
    kind = tree.kind(file_id)
1339
 
    if kind == "file":
1340
 
        return TreeFileCreate(tree, file_id)
1341
 
    elif kind in ("directory", "root_directory"):
1342
 
        return dir_create
1343
 
    elif kind == "symlink":
1344
 
        return SymlinkCreate(tree.get_symlink_target(file_id))
1345
 
    else:
1346
 
        raise UnsupportedFiletype(kind, tree.id2path(file_id))
 
1446
    def lstat(self, full_path):
 
1447
        stat_result = None
 
1448
        if full_path is not None:
 
1449
            try:
 
1450
                stat_result = os.lstat(full_path)
 
1451
            except OSError, e:
 
1452
                if e.errno != errno.ENOENT:
 
1453
                    raise
 
1454
        return stat_result
1347
1455
 
1348
1456
 
1349
1457
def full_path(entry, tree):
1350
 
    return pathjoin(tree.basedir, entry.path)
1351
 
 
 
1458
    return os.path.join(tree.root, entry.path)
1352
1459
 
1353
1460
def new_delete_entry(entry, tree, inventory, delete):
1354
1461
    if entry.path == "":
1366
1473
    status = os.lstat(full_path)
1367
1474
    if stat.S_ISDIR(file_stat.st_mode):
1368
1475
        action = dir_create
1369
 
 
1370
 
 
 
1476
    
 
1477
 
 
1478
 
 
1479
        
1371
1480
# XXX: Can't we unify this with the regular inventory object
1372
1481
class Inventory(object):
1373
1482
    def __init__(self, inventory):
1402
1511
            return None
1403
1512
        directory = self.get_dir(id)
1404
1513
        if directory == '.':
1405
 
            directory = u'./.'
 
1514
            directory = './.'
1406
1515
        if directory is None:
1407
1516
            return NULL_ID
1408
1517
        return self.get_rinventory().get(directory)
1409
 
 
1410