← 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-08-10 15:05:26 UTC
  • mto: (1092.1.41) (1185.3.4) (974.1.47)
  • mto: This revision was merged to the branch mainline in revision 1110.
  • Revision ID: abentley@panoramicfeedback.com-20050810150526-468a7e2e3dc299e4
Switched to using a set of interesting file_ids instead of SourceFile attribute

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
 
# 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
 
"""
30
 
 
 
21
"""
 
22
Represent and apply a changeset
 
23
"""
31
24
__docformat__ = "restructuredtext"
32
25
 
33
26
NULL_ID = "!NULL"
326
319
 
327
320
 
328
321
class Diff3Merge(object):
329
 
    def __init__(self, file_id, base, other):
330
 
        self.file_id = file_id
331
 
        self.base = base
332
 
        self.other = other
 
322
    def __init__(self, base_file, other_file):
 
323
        self.base_file = base_file
 
324
        self.other_file = other_file
333
325
 
334
326
    def __eq__(self, other):
335
327
        if not isinstance(other, Diff3Merge):
336
328
            return False
337
 
        return (self.base == other.base and 
338
 
                self.other == other.other and self.file_id == other.file_id)
 
329
        return (self.base_file == other.base_file and 
 
330
                self.other_file == other.other_file)
339
331
 
340
332
    def __ne__(self, other):
341
333
        return not (self == other)
342
334
 
343
335
    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)
 
336
        new_file = filename+".new" 
347
337
        if not reverse:
348
 
            base = base_file
349
 
            other = other_file
 
338
            base = self.base_file
 
339
            other = self.other_file
350
340
        else:
351
 
            base = other_file
352
 
            other = base_file
 
341
            base = self.other_file
 
342
            other = self.base_file
353
343
        status = patch.diff3(new_file, filename, base, other)
354
344
        if status == 0:
355
345
            os.chmod(new_file, os.stat(filename).st_mode)
357
347
            return
358
348
        else:
359
349
            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)
 
350
            conflict_handler.merge_conflict(new_file, filename, base, other)
368
351
 
369
352
 
370
353
def CreateDir():
626
609
                return None
627
610
            return self.path
628
611
 
629
 
    def summarize_name(self, reverse=False):
 
612
    def summarize_name(self, changeset, reverse=False):
630
613
        """Produce a one-line summary of the filename.  Indicates renames as
631
614
        old => new, indicates creation as None => new, indicates deletion as
632
615
        old => None.
663
646
        :type reverse: bool
664
647
        :rtype: str
665
648
        """
666
 
        mutter("Finding new path for %s" % self.summarize_name())
 
649
        mutter("Finding new path for %s" % self.summarize_name(changeset))
667
650
        if reverse:
668
651
            parent = self.parent
669
652
            to_dir = self.dir
997
980
 
998
981
 
999
982
class ExceptionConflictHandler(object):
1000
 
    """Default handler for merge exceptions.
1001
 
 
1002
 
    This throws an error on any kind of conflict.  Conflict handlers can
1003
 
    descend from this class if they have a better way to handle some or
1004
 
    all types of conflict.
1005
 
    """
1006
983
    def __init__(self, dir):
1007
984
        self.dir = dir
1008
985
    
1022
999
    def rename_conflict(self, id, this_name, base_name, other_name):
1023
1000
        raise RenameConflict(id, this_name, base_name, other_name)
1024
1001
 
1025
 
    def move_conflict(self, id, this_dir, base_dir, other_dir):
 
1002
    def move_conflict(self, id, inventory):
 
1003
        this_dir = inventory.this.get_dir(id)
 
1004
        base_dir = inventory.base.get_dir(id)
 
1005
        other_dir = inventory.other.get_dir(id)
1026
1006
        raise MoveConflict(id, this_dir, base_dir, other_dir)
1027
1007
 
1028
 
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
 
1008
    def merge_conflict(self, new_file, this_path, base_path, other_path):
1029
1009
        os.unlink(new_file)
1030
1010
        raise MergeConflict(this_path)
1031
1011
 
1059
1039
    def missing_for_rename(self, filename):
1060
1040
        raise MissingForRename(filename)
1061
1041
 
1062
 
    def missing_for_merge(self, file_id, other_path):
1063
 
        raise MissingForMerge(other_path)
 
1042
    def missing_for_merge(self, file_id, inventory):
 
1043
        raise MissingForMerge(inventory.other.get_path(file_id))
1064
1044
 
1065
1045
    def new_contents_conflict(self, filename, other_contents):
1066
1046
        raise NewContentsConflict(filename)
1067
1047
 
1068
 
    def finalize(self):
 
1048
    def finalize():
1069
1049
        pass
1070
1050
 
1071
1051
def apply_changeset(changeset, inventory, dir, conflict_handler=None, 
1287
1267
        self.full_path = full_path
1288
1268
        self.stat_result = stat_result
1289
1269
 
1290
 
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1291
 
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
 
1270
def generate_changeset(tree_a, tree_b, inventory_a=None, inventory_b=None, 
 
1271
                       interesting_ids=None):
 
1272
    return ChangesetGenerator(tree_a, tree_b, inventory_a, inventory_b, 
 
1273
                              interesting_ids)()
1292
1274
 
1293
1275
class ChangesetGenerator(object):
1294
 
    def __init__(self, tree_a, tree_b, interesting_ids=None):
 
1276
    def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None, 
 
1277
                 interesting_ids=None):
1295
1278
        object.__init__(self)
1296
1279
        self.tree_a = tree_a
1297
1280
        self.tree_b = tree_b
 
1281
        if inventory_a is not None:
 
1282
            self.inventory_a = inventory_a
 
1283
        else:
 
1284
            self.inventory_a = tree_a.inventory()
 
1285
        if inventory_b is not None:
 
1286
            self.inventory_b = inventory_b
 
1287
        else:
 
1288
            self.inventory_b = tree_b.inventory()
 
1289
        self.r_inventory_a = self.reverse_inventory(self.inventory_a)
 
1290
        self.r_inventory_b = self.reverse_inventory(self.inventory_b)
1298
1291
        self._interesting_ids = interesting_ids
1299
1292
 
1300
 
    def iter_both_tree_ids(self):
1301
 
        for file_id in self.tree_a:
1302
 
            yield file_id
1303
 
        for file_id in self.tree_b:
1304
 
            if file_id not in self.tree_a:
1305
 
                yield file_id
 
1293
    def reverse_inventory(self, inventory):
 
1294
        r_inventory = {}
 
1295
        for entry in inventory.itervalues():
 
1296
            if entry.id is None:
 
1297
                continue
 
1298
            r_inventory[entry.id] = entry
 
1299
        return r_inventory
1306
1300
 
1307
1301
    def __call__(self):
1308
1302
        cset = Changeset()
1309
 
        for file_id in self.iter_both_tree_ids():
1310
 
            cs_entry = self.make_entry(file_id)
 
1303
        for entry in self.inventory_a.itervalues():
 
1304
            if entry.id is None:
 
1305
                continue
 
1306
            cs_entry = self.make_entry(entry.id)
1311
1307
            if cs_entry is not None and not cs_entry.is_boring():
1312
1308
                cset.add_entry(cs_entry)
1313
1309
 
 
1310
        for entry in self.inventory_b.itervalues():
 
1311
            if entry.id is None:
 
1312
                continue
 
1313
            if not self.r_inventory_a.has_key(entry.id):
 
1314
                cs_entry = self.make_entry(entry.id)
 
1315
                if cs_entry is not None and not cs_entry.is_boring():
 
1316
                    cset.add_entry(cs_entry)
1314
1317
        for entry in list(cset.entries.itervalues()):
1315
1318
            if entry.parent != entry.new_parent:
1316
1319
                if not cset.entries.has_key(entry.parent) and\
1324
1327
                    cset.add_entry(parent_entry)
1325
1328
        return cset
1326
1329
 
1327
 
    def iter_inventory(self, tree):
1328
 
        for file_id in tree:
1329
 
            yield self.get_entry(file_id, tree)
1330
 
 
1331
 
    def get_entry(self, file_id, tree):
1332
 
        if not tree.has_or_had_id(file_id):
1333
 
            return None
1334
 
        return tree.tree.inventory[file_id]
1335
 
 
1336
 
    def get_entry_parent(self, entry):
1337
 
        if entry is None:
1338
 
            return None
1339
 
        return entry.parent_id
1340
 
 
1341
 
    def get_path(self, file_id, tree):
1342
 
        if not tree.has_or_had_id(file_id):
1343
 
            return None
1344
 
        path = tree.id2path(file_id)
1345
 
        if path == '':
1346
 
            return './.'
1347
 
        else:
1348
 
            return path
1349
 
 
1350
 
    def make_basic_entry(self, file_id, only_interesting):
1351
 
        entry_a = self.get_entry(file_id, self.tree_a)
1352
 
        entry_b = self.get_entry(file_id, self.tree_b)
 
1330
    def get_entry_parent(self, entry, inventory):
 
1331
        if entry is None:
 
1332
            return None
 
1333
        if entry.path == "./.":
 
1334
            return NULL_ID
 
1335
        dirname = os.path.dirname(entry.path)
 
1336
        if dirname == ".":
 
1337
            dirname = "./."
 
1338
        parent = inventory[dirname]
 
1339
        return parent.id
 
1340
 
 
1341
    def get_path(self, entry, tree):
 
1342
        if entry is None:
 
1343
            return (None, None)
 
1344
        if entry.path == ".":
 
1345
            return ""
 
1346
        return entry.path
 
1347
 
 
1348
    def make_basic_entry(self, id, only_interesting):
 
1349
        entry_a = self.r_inventory_a.get(id)
 
1350
        entry_b = self.r_inventory_b.get(id)
1353
1351
        if only_interesting and not self.is_interesting(entry_a, entry_b):
1354
1352
            return None
1355
 
        parent = self.get_entry_parent(entry_a)
1356
 
        path = self.get_path(file_id, self.tree_a)
1357
 
        cs_entry = ChangesetEntry(file_id, parent, path)
1358
 
        new_parent = self.get_entry_parent(entry_b)
1359
 
 
1360
 
        new_path = self.get_path(file_id, self.tree_b)
 
1353
        parent = self.get_entry_parent(entry_a, self.inventory_a)
 
1354
        path = self.get_path(entry_a, self.tree_a)
 
1355
        cs_entry = ChangesetEntry(id, parent, path)
 
1356
        new_parent = self.get_entry_parent(entry_b, self.inventory_b)
 
1357
 
 
1358
 
 
1359
        new_path = self.get_path(entry_b, self.tree_b)
1361
1360
 
1362
1361
        cs_entry.new_path = new_path
1363
1362
        cs_entry.new_parent = new_parent
1367
1366
        if self._interesting_ids is None:
1368
1367
            return True
1369
1368
        if entry_a is not None:
1370
 
            file_id = entry_a.file_id
 
1369
            file_id = entry_a.id
1371
1370
        elif entry_b is not None:
1372
 
            file_id = entry_b.file_id
 
1371
            file_id = entry_b.id
1373
1372
        else:
1374
1373
            return False
1375
1374
        return file_id in self._interesting_ids
1397
1396
        full_path_b = self.tree_b.readonly_path(id)
1398
1397
        stat_a = self.lstat(full_path_a)
1399
1398
        stat_b = self.lstat(full_path_b)
 
1399
        if stat_b is None:
 
1400
            cs_entry.new_parent = None
 
1401
            cs_entry.new_path = None
1400
1402
        
1401
1403
        cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1402
1404
        cs_entry.contents_change = self.make_contents_change(full_path_a,