/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/changeset.py

  • Committer: Robert Collins
  • Date: 2005-10-10 01:32:08 UTC
  • Revision ID: robertc@robertcollins.net-20051010013208-163c23746972763a
branch: namespace

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/changeset.py
18
18
import patch
19
19
import stat
20
20
from bzrlib.trace import mutter
21
 
"""
22
 
Represent and apply a changeset
23
 
"""
 
21
from bzrlib.osutils import rename
 
22
import bzrlib
 
23
 
 
24
# XXX: mbp: I'm not totally convinced that we should handle conflicts
 
25
# as part of changeset application, rather than only in the merge
 
26
# operation.
 
27
 
 
28
"""Represent and apply a changeset
 
29
 
 
30
Conflicts in applying a changeset are represented as exceptions.
 
31
"""
 
32
 
24
33
__docformat__ = "restructuredtext"
25
34
 
26
35
NULL_ID = "!NULL"
35
44
        newdict[value] = key
36
45
    return newdict
37
46
 
38
 
 
39
 
class PatchApply(object):
40
 
    """Patch application as a kind of content change"""
41
 
    def __init__(self, contents):
42
 
        """Constructor.
43
 
 
44
 
        :param contents: The text of the patch to apply
45
 
        :type contents: str"""
46
 
        self.contents = contents
47
 
 
48
 
    def __eq__(self, other):
49
 
        if not isinstance(other, PatchApply):
50
 
            return False
51
 
        elif self.contents != other.contents:
52
 
            return False
53
 
        else:
54
 
            return True
55
 
 
56
 
    def __ne__(self, other):
57
 
        return not (self == other)
58
 
 
59
 
    def apply(self, filename, conflict_handler, reverse=False):
60
 
        """Applies the patch to the specified file.
61
 
 
62
 
        :param filename: the file to apply the patch to
63
 
        :type filename: str
64
 
        :param reverse: If true, apply the patch in reverse
65
 
        :type reverse: bool
66
 
        """
67
 
        input_name = filename+".orig"
68
 
        try:
69
 
            os.rename(filename, input_name)
70
 
        except OSError, e:
71
 
            if e.errno != errno.ENOENT:
72
 
                raise
73
 
            if conflict_handler.patch_target_missing(filename, self.contents)\
74
 
                == "skip":
75
 
                return
76
 
            os.rename(filename, input_name)
77
 
            
78
 
 
79
 
        status = patch.patch(self.contents, input_name, filename, 
80
 
                                    reverse)
81
 
        os.chmod(filename, os.stat(input_name).st_mode)
82
 
        if status == 0:
83
 
            os.unlink(input_name)
84
 
        elif status == 1:
85
 
            conflict_handler.failed_hunks(filename)
86
 
 
87
 
        
 
47
       
88
48
class ChangeUnixPermissions(object):
89
49
    """This is two-way change, suitable for file modification, creation,
90
50
    deletion"""
133
93
    def __ne__(self, other):
134
94
        return not (self == other)
135
95
 
 
96
 
136
97
def dir_create(filename, conflict_handler, reverse):
137
98
    """Creates the directory, or deletes it if reverse is true.  Intended to be
138
99
    used with ReplaceContents.
158
119
        try:
159
120
            os.rmdir(filename)
160
121
        except OSError, e:
161
 
            if e.errno != 39:
 
122
            if e.errno != errno.ENOTEMPTY:
162
123
                raise
163
124
            if conflict_handler.rmdir_non_empty(filename) == "skip":
164
125
                return
165
126
            os.rmdir(filename)
166
127
 
167
 
                
168
 
            
169
128
 
170
129
class SymlinkCreate(object):
171
130
    """Creates or deletes a symlink (for use with ReplaceContents)"""
367
326
 
368
327
 
369
328
class Diff3Merge(object):
370
 
    def __init__(self, base_file, other_file):
371
 
        self.base_file = base_file
372
 
        self.other_file = other_file
 
329
    def __init__(self, file_id, base, other):
 
330
        self.file_id = file_id
 
331
        self.base = base
 
332
        self.other = other
373
333
 
374
334
    def __eq__(self, other):
375
335
        if not isinstance(other, Diff3Merge):
376
336
            return False
377
 
        return (self.base_file == other.base_file and 
378
 
                self.other_file == other.other_file)
 
337
        return (self.base == other.base and 
 
338
                self.other == other.other and self.file_id == other.file_id)
379
339
 
380
340
    def __ne__(self, other):
381
341
        return not (self == other)
382
342
 
383
343
    def apply(self, filename, conflict_handler, reverse=False):
384
 
        new_file = filename+".new" 
 
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)
385
347
        if not reverse:
386
 
            base = self.base_file
387
 
            other = self.other_file
 
348
            base = base_file
 
349
            other = other_file
388
350
        else:
389
 
            base = self.other_file
390
 
            other = self.base_file
 
351
            base = other_file
 
352
            other = base_file
391
353
        status = patch.diff3(new_file, filename, base, other)
392
354
        if status == 0:
393
355
            os.chmod(new_file, os.stat(filename).st_mode)
394
 
            os.rename(new_file, filename)
 
356
            rename(new_file, filename)
395
357
            return
396
358
        else:
397
359
            assert(status == 1)
398
 
            conflict_handler.merge_conflict(new_file, filename, base, other)
 
360
            def get_lines(filename):
 
361
                my_file = file(filename, "rb")
 
362
                lines = my_file.readlines()
 
363
                my_file.close()
 
364
                return lines
 
365
            base_lines = get_lines(base)
 
366
            other_lines = get_lines(other)
 
367
            conflict_handler.merge_conflict(new_file, filename, base_lines, 
 
368
                                            other_lines)
399
369
 
400
370
 
401
371
def CreateDir():
657
627
                return None
658
628
            return self.path
659
629
 
660
 
    def summarize_name(self, changeset, reverse=False):
 
630
    def summarize_name(self, reverse=False):
661
631
        """Produce a one-line summary of the filename.  Indicates renames as
662
632
        old => new, indicates creation as None => new, indicates deletion as
663
633
        old => None.
694
664
        :type reverse: bool
695
665
        :rtype: str
696
666
        """
697
 
        mutter("Finding new path for %s" % self.summarize_name(changeset))
 
667
        mutter("Finding new path for %s" % self.summarize_name())
698
668
        if reverse:
699
669
            parent = self.parent
700
670
            to_dir = self.dir
862
832
            if src_path is not None:
863
833
                src_path = os.path.join(dir, src_path)
864
834
                try:
865
 
                    os.rename(src_path, to_name)
 
835
                    rename(src_path, to_name)
866
836
                    temp_name[entry.id] = to_name
867
837
                except OSError, e:
868
838
                    if e.errno != errno.ENOENT:
894
864
            continue
895
865
        new_path = os.path.join(dir, new_tree_path)
896
866
        old_path = changed_inventory.get(entry.id)
897
 
        if os.path.exists(new_path):
 
867
        if bzrlib.osutils.lexists(new_path):
898
868
            if conflict_handler.target_exists(entry, new_path, old_path) == \
899
869
                "skip":
900
870
                continue
905
875
            if old_path is None:
906
876
                continue
907
877
            try:
908
 
                os.rename(old_path, new_path)
 
878
                rename(old_path, new_path)
909
879
                changed_inventory[entry.id] = new_tree_path
910
880
            except OSError, e:
911
881
                raise Exception ("%s is missing" % new_path)
1028
998
 
1029
999
 
1030
1000
class ExceptionConflictHandler(object):
1031
 
    def __init__(self, dir):
1032
 
        self.dir = dir
1033
 
    
 
1001
    """Default handler for merge exceptions.
 
1002
 
 
1003
    This throws an error on any kind of conflict.  Conflict handlers can
 
1004
    descend from this class if they have a better way to handle some or
 
1005
    all types of conflict.
 
1006
    """
1034
1007
    def missing_parent(self, pathname):
1035
1008
        parent = os.path.dirname(pathname)
1036
1009
        raise Exception("Parent directory missing for %s" % pathname)
1047
1020
    def rename_conflict(self, id, this_name, base_name, other_name):
1048
1021
        raise RenameConflict(id, this_name, base_name, other_name)
1049
1022
 
1050
 
    def move_conflict(self, id, inventory):
1051
 
        this_dir = inventory.this.get_dir(id)
1052
 
        base_dir = inventory.base.get_dir(id)
1053
 
        other_dir = inventory.other.get_dir(id)
 
1023
    def move_conflict(self, id, this_dir, base_dir, other_dir):
1054
1024
        raise MoveConflict(id, this_dir, base_dir, other_dir)
1055
1025
 
1056
 
    def merge_conflict(self, new_file, this_path, base_path, other_path):
 
1026
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1057
1027
        os.unlink(new_file)
1058
1028
        raise MergeConflict(this_path)
1059
1029
 
1087
1057
    def missing_for_rename(self, filename):
1088
1058
        raise MissingForRename(filename)
1089
1059
 
1090
 
    def missing_for_merge(self, file_id, inventory):
1091
 
        raise MissingForMerge(inventory.other.get_path(file_id))
 
1060
    def missing_for_merge(self, file_id, other_path):
 
1061
        raise MissingForMerge(other_path)
1092
1062
 
1093
1063
    def new_contents_conflict(self, filename, other_contents):
1094
1064
        raise NewContentsConflict(filename)
1095
1065
 
1096
 
    def finalize():
 
1066
    def finalize(self):
1097
1067
        pass
1098
1068
 
1099
1069
def apply_changeset(changeset, inventory, dir, conflict_handler=None, 
1112
1082
    :rtype: Dictionary
1113
1083
    """
1114
1084
    if conflict_handler is None:
1115
 
        conflict_handler = ExceptionConflictHandler(dir)
 
1085
        conflict_handler = ExceptionConflictHandler()
1116
1086
    temp_dir = os.path.join(dir, "bzr-tree-change")
1117
1087
    try:
1118
1088
        os.mkdir(temp_dir)
1315
1285
        self.full_path = full_path
1316
1286
        self.stat_result = stat_result
1317
1287
 
1318
 
def generate_changeset(tree_a, tree_b, inventory_a=None, inventory_b=None):
1319
 
    return ChangesetGenerator(tree_a, tree_b, inventory_a, inventory_b)()
 
1288
def generate_changeset(tree_a, tree_b, interesting_ids=None):
 
1289
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1320
1290
 
1321
1291
class ChangesetGenerator(object):
1322
 
    def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
 
1292
    def __init__(self, tree_a, tree_b, interesting_ids=None):
1323
1293
        object.__init__(self)
1324
1294
        self.tree_a = tree_a
1325
1295
        self.tree_b = tree_b
1326
 
        if inventory_a is not None:
1327
 
            self.inventory_a = inventory_a
1328
 
        else:
1329
 
            self.inventory_a = tree_a.inventory()
1330
 
        if inventory_b is not None:
1331
 
            self.inventory_b = inventory_b
1332
 
        else:
1333
 
            self.inventory_b = tree_b.inventory()
1334
 
        self.r_inventory_a = self.reverse_inventory(self.inventory_a)
1335
 
        self.r_inventory_b = self.reverse_inventory(self.inventory_b)
 
1296
        self._interesting_ids = interesting_ids
1336
1297
 
1337
 
    def reverse_inventory(self, inventory):
1338
 
        r_inventory = {}
1339
 
        for entry in inventory.itervalues():
1340
 
            if entry.id is None:
1341
 
                continue
1342
 
            r_inventory[entry.id] = entry
1343
 
        return r_inventory
 
1298
    def iter_both_tree_ids(self):
 
1299
        for file_id in self.tree_a:
 
1300
            yield file_id
 
1301
        for file_id in self.tree_b:
 
1302
            if file_id not in self.tree_a:
 
1303
                yield file_id
1344
1304
 
1345
1305
    def __call__(self):
1346
1306
        cset = Changeset()
1347
 
        for entry in self.inventory_a.itervalues():
1348
 
            if entry.id is None:
1349
 
                continue
1350
 
            cs_entry = self.make_entry(entry.id)
 
1307
        for file_id in self.iter_both_tree_ids():
 
1308
            cs_entry = self.make_entry(file_id)
1351
1309
            if cs_entry is not None and not cs_entry.is_boring():
1352
1310
                cset.add_entry(cs_entry)
1353
1311
 
1354
 
        for entry in self.inventory_b.itervalues():
1355
 
            if entry.id is None:
1356
 
                continue
1357
 
            if not self.r_inventory_a.has_key(entry.id):
1358
 
                cs_entry = self.make_entry(entry.id)
1359
 
                if cs_entry is not None and not cs_entry.is_boring():
1360
 
                    cset.add_entry(cs_entry)
1361
1312
        for entry in list(cset.entries.itervalues()):
1362
1313
            if entry.parent != entry.new_parent:
1363
1314
                if not cset.entries.has_key(entry.parent) and\
1371
1322
                    cset.add_entry(parent_entry)
1372
1323
        return cset
1373
1324
 
1374
 
    def get_entry_parent(self, entry, inventory):
1375
 
        if entry is None:
1376
 
            return None
1377
 
        if entry.path == "./.":
1378
 
            return NULL_ID
1379
 
        dirname = os.path.dirname(entry.path)
1380
 
        if dirname == ".":
1381
 
            dirname = "./."
1382
 
        parent = inventory[dirname]
1383
 
        return parent.id
1384
 
 
1385
 
    def get_paths(self, entry, tree):
1386
 
        if entry is None:
1387
 
            return (None, None)
1388
 
        full_path = tree.readonly_path(entry.id)
1389
 
        if entry.path == ".":
1390
 
            return ("", full_path)
1391
 
        return (entry.path, full_path)
1392
 
 
1393
 
    def make_basic_entry(self, id, only_interesting):
1394
 
        entry_a = self.r_inventory_a.get(id)
1395
 
        entry_b = self.r_inventory_b.get(id)
 
1325
    def iter_inventory(self, tree):
 
1326
        for file_id in tree:
 
1327
            yield self.get_entry(file_id, tree)
 
1328
 
 
1329
    def get_entry(self, file_id, tree):
 
1330
        if not tree.has_or_had_id(file_id):
 
1331
            return None
 
1332
        return tree.tree.inventory[file_id]
 
1333
 
 
1334
    def get_entry_parent(self, entry):
 
1335
        if entry is None:
 
1336
            return None
 
1337
        return entry.parent_id
 
1338
 
 
1339
    def get_path(self, file_id, tree):
 
1340
        if not tree.has_or_had_id(file_id):
 
1341
            return None
 
1342
        path = tree.id2path(file_id)
 
1343
        if path == '':
 
1344
            return './.'
 
1345
        else:
 
1346
            return path
 
1347
 
 
1348
    def make_basic_entry(self, file_id, only_interesting):
 
1349
        entry_a = self.get_entry(file_id, self.tree_a)
 
1350
        entry_b = self.get_entry(file_id, self.tree_b)
1396
1351
        if only_interesting and not self.is_interesting(entry_a, entry_b):
1397
 
            return (None, None, None)
1398
 
        parent = self.get_entry_parent(entry_a, self.inventory_a)
1399
 
        (path, full_path_a) = self.get_paths(entry_a, self.tree_a)
1400
 
        cs_entry = ChangesetEntry(id, parent, path)
1401
 
        new_parent = self.get_entry_parent(entry_b, self.inventory_b)
1402
 
 
1403
 
 
1404
 
        (new_path, full_path_b) = self.get_paths(entry_b, self.tree_b)
 
1352
            return None
 
1353
        parent = self.get_entry_parent(entry_a)
 
1354
        path = self.get_path(file_id, self.tree_a)
 
1355
        cs_entry = ChangesetEntry(file_id, parent, path)
 
1356
        new_parent = self.get_entry_parent(entry_b)
 
1357
 
 
1358
        new_path = self.get_path(file_id, self.tree_b)
1405
1359
 
1406
1360
        cs_entry.new_path = new_path
1407
1361
        cs_entry.new_parent = new_parent
1408
 
        return (cs_entry, full_path_a, full_path_b)
 
1362
        return cs_entry
1409
1363
 
1410
1364
    def is_interesting(self, entry_a, entry_b):
 
1365
        if self._interesting_ids is None:
 
1366
            return True
1411
1367
        if entry_a is not None:
1412
 
            if entry_a.interesting:
1413
 
                return True
1414
 
        if entry_b is not None:
1415
 
            if entry_b.interesting:
1416
 
                return True
1417
 
        return False
 
1368
            file_id = entry_a.file_id
 
1369
        elif entry_b is not None:
 
1370
            file_id = entry_b.file_id
 
1371
        else:
 
1372
            return False
 
1373
        return file_id in self._interesting_ids
1418
1374
 
1419
1375
    def make_boring_entry(self, id):
1420
 
        (cs_entry, full_path_a, full_path_b) = \
1421
 
            self.make_basic_entry(id, only_interesting=False)
 
1376
        cs_entry = self.make_basic_entry(id, only_interesting=False)
1422
1377
        if cs_entry.is_creation_or_deletion():
1423
1378
            return self.make_entry(id, only_interesting=False)
1424
1379
        else:
1426
1381
        
1427
1382
 
1428
1383
    def make_entry(self, id, only_interesting=True):
1429
 
        (cs_entry, full_path_a, full_path_b) = \
1430
 
            self.make_basic_entry(id, only_interesting)
 
1384
        cs_entry = self.make_basic_entry(id, only_interesting)
1431
1385
 
1432
1386
        if cs_entry is None:
1433
1387
            return None
1434
 
       
 
1388
 
 
1389
        full_path_a = self.tree_a.readonly_path(id)
 
1390
        full_path_b = self.tree_b.readonly_path(id)
1435
1391
        stat_a = self.lstat(full_path_a)
1436
1392
        stat_b = self.lstat(full_path_b)
1437
 
        if stat_b is None:
1438
 
            cs_entry.new_parent = None
1439
 
            cs_entry.new_path = None
1440
 
        
 
1393
 
1441
1394
        cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
 
1395
 
 
1396
        if id in self.tree_a and id in self.tree_b:
 
1397
            a_sha1 = self.tree_a.get_file_sha1(id)
 
1398
            b_sha1 = self.tree_b.get_file_sha1(id)
 
1399
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
 
1400
                return cs_entry
 
1401
 
1442
1402
        cs_entry.contents_change = self.make_contents_change(full_path_a,
1443
1403
                                                             stat_a, 
1444
1404
                                                             full_path_b, 
1467
1427
            if stat_a.st_ino == stat_b.st_ino and \
1468
1428
                stat_a.st_dev == stat_b.st_dev:
1469
1429
                return None
1470
 
            if file(full_path_a, "rb").read() == \
1471
 
                file(full_path_b, "rb").read():
1472
 
                return None
1473
 
 
1474
 
            patch_contents = patch.diff(full_path_a, 
1475
 
                                        file(full_path_b, "rb").read())
1476
 
            if patch_contents is None:
1477
 
                return None
1478
 
            return PatchApply(patch_contents)
1479
1430
 
1480
1431
        a_contents = self.get_contents(stat_a, full_path_a)
1481
1432
        b_contents = self.get_contents(stat_b, full_path_b)