← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/changeset.py

- constraints on revprops
- tests for this

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/changeset.py
17
17
import errno
18
18
import patch
19
19
import stat
20
 
from tempfile import mkdtemp
21
 
from shutil import rmtree
22
20
from bzrlib.trace import mutter
23
 
from bzrlib.osutils import rename, sha_file
 
21
from bzrlib.osutils import rename
24
22
import bzrlib
25
 
from itertools import izip
26
23
 
27
24
# XXX: mbp: I'm not totally convinced that we should handle conflicts
28
25
# as part of changeset application, rather than only in the merge
146
143
        """
147
144
        self.target = contents
148
145
 
149
 
    def __repr__(self):
150
 
        return "SymlinkCreate(%s)" % self.target
151
 
 
152
146
    def __call__(self, filename, conflict_handler, reverse):
153
147
        """Creates or destroys the symlink.
154
148
 
236
230
 
237
231
                    
238
232
 
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
 
 
305
233
def reversed(sequence):
306
234
    max = len(sequence) - 1
307
235
    for i in range(len(sequence)):
374
302
            if mode is not None:
375
303
                os.chmod(filename, mode)
376
304
 
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
 
 
383
305
class ApplySequence(object):
384
306
    def __init__(self, changes=None):
385
307
        self.changes = []
411
333
 
412
334
 
413
335
class Diff3Merge(object):
414
 
    history_based = False
415
336
    def __init__(self, file_id, base, other):
416
337
        self.file_id = file_id
417
338
        self.base = base
418
339
        self.other = other
419
340
 
420
 
    def is_creation(self):
421
 
        return False
422
 
 
423
 
    def is_deletion(self):
424
 
        return False
425
 
 
426
341
    def __eq__(self, other):
427
342
        if not isinstance(other, Diff3Merge):
428
343
            return False
432
347
    def __ne__(self, other):
433
348
        return not (self == other)
434
349
 
435
 
    def dump_file(self, temp_dir, name, tree):
436
 
        out_path = os.path.join(temp_dir, name)
437
 
        out_file = file(out_path, "wb")
438
 
        in_file = tree.get_file(self.file_id)
439
 
        for line in in_file:
440
 
            out_file.write(line)
441
 
        return out_path
442
 
 
443
350
    def apply(self, filename, conflict_handler, reverse=False):
444
 
        temp_dir = mkdtemp(prefix="bzr-")
445
 
        try:
446
 
            new_file = filename+".new"
447
 
            base_file = self.dump_file(temp_dir, "base", self.base)
448
 
            other_file = self.dump_file(temp_dir, "other", self.other)
449
 
            if not reverse:
450
 
                base = base_file
451
 
                other = other_file
452
 
            else:
453
 
                base = other_file
454
 
                other = base_file
455
 
            status = patch.diff3(new_file, filename, base, other)
456
 
            if status == 0:
457
 
                os.chmod(new_file, os.stat(filename).st_mode)
458
 
                rename(new_file, filename)
459
 
                return
460
 
            else:
461
 
                assert(status == 1)
462
 
                def get_lines(filename):
463
 
                    my_file = file(filename, "rb")
464
 
                    lines = my_file.readlines()
465
 
                    my_file.close()
466
 
                    return lines
467
 
                base_lines = get_lines(base)
468
 
                other_lines = get_lines(other)
469
 
                conflict_handler.merge_conflict(new_file, filename, base_lines, 
470
 
                                                other_lines)
471
 
        finally:
472
 
            rmtree(temp_dir)
 
351
        new_file = filename+".new"
 
352
        base_file = self.base.readonly_path(self.file_id)
 
353
        other_file = self.other.readonly_path(self.file_id)
 
354
        if not reverse:
 
355
            base = base_file
 
356
            other = other_file
 
357
        else:
 
358
            base = other_file
 
359
            other = base_file
 
360
        status = patch.diff3(new_file, filename, base, other)
 
361
        if status == 0:
 
362
            os.chmod(new_file, os.stat(filename).st_mode)
 
363
            rename(new_file, filename)
 
364
            return
 
365
        else:
 
366
            assert(status == 1)
 
367
            def get_lines(filename):
 
368
                my_file = file(filename, "rb")
 
369
                lines = my_file.readlines()
 
370
                my_file.close()
 
371
                return lines
 
372
            base_lines = get_lines(base)
 
373
            other_lines = get_lines(other)
 
374
            conflict_handler.merge_conflict(new_file, filename, base_lines, 
 
375
                                            other_lines)
473
376
 
474
377
 
475
378
def CreateDir():
508
411
    """
509
412
    return ReplaceContents(FileCreate(contents), None)
510
413
 
511
 
def ReplaceFileContents(old_tree, new_tree, file_id):
 
414
def ReplaceFileContents(old_contents, new_contents):
512
415
    """Convenience fucntion to replace the contents of a file.
513
416
    
514
417
    :param old_contents: The contents of the file to replace 
518
421
    :return: A ReplaceContents that will replace the contents of a file a file 
519
422
    :rtype: `ReplaceContents`
520
423
    """
521
 
    return ReplaceContents(TreeFileCreate(old_tree, file_id), 
522
 
                           TreeFileCreate(new_tree, file_id))
 
424
    return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
523
425
 
524
426
def CreateSymlink(target):
525
427
    """Convenience fucntion to create a symlink.
688
590
        :param reverse: if true, the changeset is being applied in reverse
689
591
        :rtype: bool
690
592
        """
691
 
        return self.is_creation(not reverse)
 
593
        return ((self.new_parent is None and not reverse) or 
 
594
                (self.parent is None and reverse))
692
595
 
693
596
    def is_creation(self, reverse):
694
597
        """Return true if applying the entry would create a file/directory.
696
599
        :param reverse: if true, the changeset is being applied in reverse
697
600
        :rtype: bool
698
601
        """
699
 
        if self.contents_change is None:
700
 
            return False
701
 
        if reverse:
702
 
            return self.contents_change.is_deletion()
703
 
        else:
704
 
            return self.contents_change.is_creation()
 
602
        return ((self.parent is None and not reverse) or 
 
603
                (self.new_parent is None and reverse))
705
604
 
706
605
    def is_creation_or_deletion(self):
707
606
        """Return true if applying the entry would create or delete a 
709
608
 
710
609
        :rtype: bool
711
610
        """
712
 
        return self.is_creation(False) or self.is_deletion(False)
 
611
        return self.parent is None or self.new_parent is None
713
612
 
714
613
    def get_cset_path(self, mod=False):
715
614
        """Determine the path of the entry according to the changeset.
887
786
    :rtype: (List, List)
888
787
    """
889
788
    source_entries = [x for x in changeset.entries.itervalues() 
890
 
                      if x.needs_rename() or x.is_creation_or_deletion()]
 
789
                      if x.needs_rename()]
891
790
    # these are done from longest path to shortest, to avoid deleting a
892
791
    # parent before its children are deleted/renamed 
893
792
    def longest_to_shortest(entry):
934
833
            entry.apply(path, conflict_handler, reverse)
935
834
            temp_name[entry.id] = None
936
835
 
937
 
        elif entry.needs_rename():
 
836
        else:
938
837
            to_name = os.path.join(temp_dir, str(i))
939
838
            src_path = inventory.get(entry.id)
940
839
            if src_path is not None:
945
844
                except OSError, e:
946
845
                    if e.errno != errno.ENOENT:
947
846
                        raise
948
 
                    if conflict_handler.missing_for_rename(src_path, to_name) \
949
 
                        == "skip":
 
847
                    if conflict_handler.missing_for_rename(src_path) == "skip":
950
848
                        continue
951
849
 
952
850
    return temp_name
980
878
        if entry.is_creation(reverse):
981
879
            entry.apply(new_path, conflict_handler, reverse)
982
880
            changed_inventory[entry.id] = new_tree_path
983
 
        elif entry.needs_rename():
 
881
        else:
984
882
            if old_path is None:
985
883
                continue
986
884
            try:
1073
971
 
1074
972
 
1075
973
class MissingForRename(Exception):
1076
 
    def __init__(self, filename, to_path):
1077
 
        msg = "Attempt to move missing path %s to %s" % (filename, to_path)
 
974
    def __init__(self, filename):
 
975
        msg = "Attempt to move missing path %s" % (filename)
1078
976
        Exception.__init__(self, msg)
1079
977
        self.filename = filename
1080
978
 
1083
981
        msg = "Conflicting contents for new file %s" % (filename)
1084
982
        Exception.__init__(self, msg)
1085
983
 
1086
 
class WeaveMergeConflict(Exception):
1087
 
    def __init__(self, filename):
1088
 
        msg = "Conflicting contents for file %s" % (filename)
1089
 
        Exception.__init__(self, msg)
1090
 
 
1091
 
class ThreewayContentsConflict(Exception):
1092
 
    def __init__(self, filename):
1093
 
        msg = "Conflicting contents for file %s" % (filename)
1094
 
        Exception.__init__(self, msg)
1095
 
 
1096
984
 
1097
985
class MissingForMerge(Exception):
1098
986
    def __init__(self, filename):
1155
1043
    def missing_for_rm(self, filename, change):
1156
1044
        raise MissingForRm(filename)
1157
1045
 
1158
 
    def missing_for_rename(self, filename, to_path):
1159
 
        raise MissingForRename(filename, to_path)
 
1046
    def missing_for_rename(self, filename):
 
1047
        raise MissingForRename(filename)
1160
1048
 
1161
1049
    def missing_for_merge(self, file_id, other_path):
1162
1050
        raise MissingForMerge(other_path)
1164
1052
    def new_contents_conflict(self, filename, other_contents):
1165
1053
        raise NewContentsConflict(filename)
1166
1054
 
1167
 
    def weave_merge_conflict(self, filename, weave, other_i, out_file):
1168
 
        raise WeaveMergeConflict(filename)
1169
 
 
1170
 
    def threeway_contents_conflict(self, filename, this_contents,
1171
 
                                   base_contents, other_contents):
1172
 
        raise ThreewayContentsConflict(filename)
1173
 
 
1174
1055
    def finalize(self):
1175
1056
        pass
1176
1057
 
1207
1088
    
1208
1089
    #apply changes that don't affect filenames
1209
1090
    for entry in changeset.entries.itervalues():
1210
 
        if not entry.is_creation_or_deletion() and not entry.is_boring():
 
1091
        if not entry.is_creation_or_deletion():
1211
1092
            path = os.path.join(dir, inventory[entry.id])
1212
1093
            entry.apply(path, conflict_handler, reverse)
1213
1094
 
1232
1113
    r_inventory = {}
1233
1114
    for entry in tree.source_inventory().itervalues():
1234
1115
        inventory[entry.id] = entry.path
1235
 
    new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
 
1116
    new_inventory = apply_changeset(cset, r_inventory, tree.root,
1236
1117
                                    reverse=reverse)
1237
1118
    new_entries, remove_entries = \
1238
1119
        get_inventory_change(inventory, new_inventory, cset, reverse)
1386
1267
            return False
1387
1268
    return True
1388
1269
 
1389
 
class UnsupportedFiletype(Exception):
1390
 
    def __init__(self, kind, full_path):
1391
 
        msg = "The file \"%s\" is a %s, which is not a supported filetype." \
1392
 
            % (full_path, kind)
 
1270
class UnsuppportedFiletype(Exception):
 
1271
    def __init__(self, full_path, stat_result):
 
1272
        msg = "The file \"%s\" is not a supported filetype." % full_path
1393
1273
        Exception.__init__(self, msg)
1394
1274
        self.full_path = full_path
1395
 
        self.kind = kind
 
1275
        self.stat_result = stat_result
1396
1276
 
1397
1277
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1398
1278
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1439
1319
    def get_entry(self, file_id, tree):
1440
1320
        if not tree.has_or_had_id(file_id):
1441
1321
            return None
1442
 
        return tree.inventory[file_id]
 
1322
        return tree.tree.inventory[file_id]
1443
1323
 
1444
1324
    def get_entry_parent(self, entry):
1445
1325
        if entry is None:
1496
1376
        if cs_entry is None:
1497
1377
            return None
1498
1378
 
1499
 
        cs_entry.metadata_change = self.make_exec_flag_change(id)
 
1379
        full_path_a = self.tree_a.readonly_path(id)
 
1380
        full_path_b = self.tree_b.readonly_path(id)
 
1381
        stat_a = self.lstat(full_path_a)
 
1382
        stat_b = self.lstat(full_path_b)
 
1383
 
 
1384
        cs_entry.metadata_change = self.make_exec_flag_change(stat_a, stat_b)
1500
1385
 
1501
1386
        if id in self.tree_a and id in self.tree_b:
1502
1387
            a_sha1 = self.tree_a.get_file_sha1(id)
1504
1389
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1505
1390
                return cs_entry
1506
1391
 
1507
 
        cs_entry.contents_change = self.make_contents_change(id)
 
1392
        cs_entry.contents_change = self.make_contents_change(full_path_a,
 
1393
                                                             stat_a, 
 
1394
                                                             full_path_b, 
 
1395
                                                             stat_b)
1508
1396
        return cs_entry
1509
1397
 
1510
 
    def make_exec_flag_change(self, file_id):
 
1398
    def make_exec_flag_change(self, stat_a, stat_b):
1511
1399
        exec_flag_a = exec_flag_b = None
1512
 
        if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
1513
 
            exec_flag_a = self.tree_a.is_executable(file_id)
1514
 
 
1515
 
        if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
1516
 
            exec_flag_b = self.tree_b.is_executable(file_id)
1517
 
 
 
1400
        if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
 
1401
            exec_flag_a = bool(stat_a.st_mode & 0111)
 
1402
        if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
 
1403
            exec_flag_b = bool(stat_b.st_mode & 0111)
1518
1404
        if exec_flag_a == exec_flag_b:
1519
1405
            return None
1520
1406
        return ChangeExecFlag(exec_flag_a, exec_flag_b)
1521
1407
 
1522
 
    def make_contents_change(self, file_id):
1523
 
        a_contents = get_contents(self.tree_a, file_id)
1524
 
        b_contents = get_contents(self.tree_b, file_id)
 
1408
    def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
 
1409
        if stat_a is None and stat_b is None:
 
1410
            return None
 
1411
        if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
 
1412
            stat.S_ISDIR(stat_b.st_mode):
 
1413
            return None
 
1414
        if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
 
1415
            stat.S_ISREG(stat_b.st_mode):
 
1416
            if stat_a.st_ino == stat_b.st_ino and \
 
1417
                stat_a.st_dev == stat_b.st_dev:
 
1418
                return None
 
1419
 
 
1420
        a_contents = self.get_contents(stat_a, full_path_a)
 
1421
        b_contents = self.get_contents(stat_b, full_path_b)
1525
1422
        if a_contents == b_contents:
1526
1423
            return None
1527
1424
        return ReplaceContents(a_contents, b_contents)
1528
1425
 
 
1426
    def get_contents(self, stat_result, full_path):
 
1427
        if stat_result is None:
 
1428
            return None
 
1429
        elif stat.S_ISREG(stat_result.st_mode):
 
1430
            return FileCreate(file(full_path, "rb").read())
 
1431
        elif stat.S_ISDIR(stat_result.st_mode):
 
1432
            return dir_create
 
1433
        elif stat.S_ISLNK(stat_result.st_mode):
 
1434
            return SymlinkCreate(os.readlink(full_path))
 
1435
        else:
 
1436
            raise UnsupportedFiletype(full_path, stat_result)
1529
1437
 
1530
 
def get_contents(tree, file_id):
1531
 
    """Return the appropriate contents to create a copy of file_id from tree"""
1532
 
    if file_id not in tree:
1533
 
        return None
1534
 
    kind = tree.kind(file_id)
1535
 
    if kind == "file":
1536
 
        return TreeFileCreate(tree, file_id)
1537
 
    elif kind in ("directory", "root_directory"):
1538
 
        return dir_create
1539
 
    elif kind == "symlink":
1540
 
        return SymlinkCreate(tree.get_symlink_target(file_id))
1541
 
    else:
1542
 
        raise UnsupportedFiletype(kind, tree.id2path(file_id))
 
1438
    def lstat(self, full_path):
 
1439
        stat_result = None
 
1440
        if full_path is not None:
 
1441
            try:
 
1442
                stat_result = os.lstat(full_path)
 
1443
            except OSError, e:
 
1444
                if e.errno != errno.ENOENT:
 
1445
                    raise
 
1446
        return stat_result
1543
1447
 
1544
1448
 
1545
1449
def full_path(entry, tree):
1546
 
    return os.path.join(tree.basedir, entry.path)
 
1450
    return os.path.join(tree.root, entry.path)
1547
1451
 
1548
1452
def new_delete_entry(entry, tree, inventory, delete):
1549
1453
    if entry.path == "":