~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/changeset.py

  • Committer: aaron.bentley at utoronto
  • Date: 2005-09-05 01:31:37 UTC
  • mto: (1185.3.4)
  • mto: This revision was merged to the branch mainline in revision 1178.
  • Revision ID: aaron.bentley@utoronto.ca-20050905013137-c8b598b5a90a52a9
Fixed the revno bug in log

Show diffs side-by-side

added added

removed removed

Lines of Context:
17
17
import errno
18
18
import patch
19
19
import stat
20
 
"""
21
 
Represent and apply a changeset
22
 
"""
 
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
 
23
31
__docformat__ = "restructuredtext"
24
32
 
25
33
NULL_ID = "!NULL"
26
34
 
27
 
 
 
35
class OldFailedTreeOp(Exception):
 
36
    def __init__(self):
 
37
        Exception.__init__(self, "bzr-tree-change contains files from a"
 
38
                           " previous failed merge operation.")
28
39
def invert_dict(dict):
29
40
    newdict = {}
30
41
    for (key,value) in dict.iteritems():
32
43
    return newdict
33
44
 
34
45
 
35
 
class PatchApply(object):
36
 
    """Patch application as a kind of content change"""
37
 
    def __init__(self, contents):
38
 
        """Constructor.
39
 
 
40
 
        :param contents: The text of the patch to apply
41
 
        :type contents: str"""
42
 
        self.contents = contents
43
 
 
44
 
    def __eq__(self, other):
45
 
        if not isinstance(other, PatchApply):
46
 
            return False
47
 
        elif self.contents != other.contents:
48
 
            return False
49
 
        else:
50
 
            return True
51
 
 
52
 
    def __ne__(self, other):
53
 
        return not (self == other)
54
 
 
55
 
    def apply(self, filename, conflict_handler, reverse=False):
56
 
        """Applies the patch to the specified file.
57
 
 
58
 
        :param filename: the file to apply the patch to
59
 
        :type filename: str
60
 
        :param reverse: If true, apply the patch in reverse
61
 
        :type reverse: bool
62
 
        """
63
 
        input_name = filename+".orig"
64
 
        try:
65
 
            os.rename(filename, input_name)
66
 
        except OSError, e:
67
 
            if e.errno != errno.ENOENT:
68
 
                raise
69
 
            if conflict_handler.patch_target_missing(filename, self.contents)\
70
 
                == "skip":
71
 
                return
72
 
            os.rename(filename, input_name)
73
 
            
74
 
 
75
 
        status = patch.patch(self.contents, input_name, filename, 
76
 
                                    reverse)
77
 
        os.chmod(filename, os.stat(input_name).st_mode)
78
 
        if status == 0:
79
 
            os.unlink(input_name)
80
 
        elif status == 1:
81
 
            conflict_handler.failed_hunks(filename)
82
 
 
83
 
        
 
46
       
84
47
class ChangeUnixPermissions(object):
85
48
    """This is two-way change, suitable for file modification, creation,
86
49
    deletion"""
363
326
 
364
327
 
365
328
class Diff3Merge(object):
366
 
    def __init__(self, base_file, other_file):
367
 
        self.base_file = base_file
368
 
        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
369
333
 
370
334
    def __eq__(self, other):
371
335
        if not isinstance(other, Diff3Merge):
372
336
            return False
373
 
        return (self.base_file == other.base_file and 
374
 
                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)
375
339
 
376
340
    def __ne__(self, other):
377
341
        return not (self == other)
378
342
 
379
343
    def apply(self, filename, conflict_handler, reverse=False):
380
 
        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)
381
347
        if not reverse:
382
 
            base = self.base_file
383
 
            other = self.other_file
 
348
            base = base_file
 
349
            other = other_file
384
350
        else:
385
 
            base = self.other_file
386
 
            other = self.base_file
 
351
            base = other_file
 
352
            other = base_file
387
353
        status = patch.diff3(new_file, filename, base, other)
388
354
        if status == 0:
389
355
            os.chmod(new_file, os.stat(filename).st_mode)
391
357
            return
392
358
        else:
393
359
            assert(status == 1)
394
 
            conflict_handler.merge_conflict(new_file, filename, base, other)
 
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)
395
368
 
396
369
 
397
370
def CreateDir():
653
626
                return None
654
627
            return self.path
655
628
 
656
 
    def summarize_name(self, changeset, reverse=False):
 
629
    def summarize_name(self, reverse=False):
657
630
        """Produce a one-line summary of the filename.  Indicates renames as
658
631
        old => new, indicates creation as None => new, indicates deletion as
659
632
        old => None.
690
663
        :type reverse: bool
691
664
        :rtype: str
692
665
        """
 
666
        mutter("Finding new path for %s" % self.summarize_name())
693
667
        if reverse:
694
668
            parent = self.parent
695
669
            to_dir = self.dir
714
688
        if from_dir == to_dir:
715
689
            dir = os.path.dirname(id_map[self.id])
716
690
        else:
 
691
            mutter("path, new_path: %r %r" % (self.path, self.new_path))
717
692
            parent_entry = changeset.entries[parent]
718
693
            dir = parent_entry.get_new_path(id_map, changeset, reverse)
719
694
        if from_name == to_name:
826
801
    my_sort(target_entries, shortest_to_longest)
827
802
    return (source_entries, target_entries)
828
803
 
829
 
def rename_to_temp_delete(source_entries, inventory, dir, conflict_handler,
830
 
                          reverse):
 
804
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir, 
 
805
                          conflict_handler, reverse):
831
806
    """Delete and rename entries as appropriate.  Entries are renamed to temp
832
 
    names.  A map of id -> temp name is returned.
 
807
    names.  A map of id -> temp name (or None, for deletions) is returned.
833
808
 
834
809
    :param source_entries: The entries to rename and delete
835
810
    :type source_entries: List of `ChangesetEntry`
842
817
    :return: a mapping of id to temporary name
843
818
    :rtype: Dictionary
844
819
    """
845
 
    temp_dir = os.path.join(dir, "temp")
846
820
    temp_name = {}
847
821
    for i in range(len(source_entries)):
848
822
        entry = source_entries[i]
849
823
        if entry.is_deletion(reverse):
850
824
            path = os.path.join(dir, inventory[entry.id])
851
825
            entry.apply(path, conflict_handler, reverse)
 
826
            temp_name[entry.id] = None
852
827
 
853
828
        else:
854
 
            to_name = temp_dir+"/"+str(i)
 
829
            to_name = os.path.join(temp_dir, str(i))
855
830
            src_path = inventory.get(entry.id)
856
831
            if src_path is not None:
857
832
                src_path = os.path.join(dir, src_path)
867
842
    return temp_name
868
843
 
869
844
 
870
 
def rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
871
 
                         conflict_handler, reverse):
 
845
def rename_to_new_create(changed_inventory, target_entries, inventory, 
 
846
                         changeset, dir, conflict_handler, reverse):
872
847
    """Rename entries with temp names to their final names, create new files.
873
848
 
874
 
    :param temp_name: A mapping of id to temporary name
875
 
    :type temp_name: Dictionary
 
849
    :param changed_inventory: A mapping of id to temporary name
 
850
    :type changed_inventory: Dictionary
876
851
    :param target_entries: The entries to apply changes to
877
852
    :type target_entries: List of `ChangesetEntry`
878
853
    :param changeset: The changeset to apply
883
858
    :type reverse: bool
884
859
    """
885
860
    for entry in target_entries:
886
 
        new_path = entry.get_new_path(inventory, changeset, reverse)
887
 
        if new_path is None:
 
861
        new_tree_path = entry.get_new_path(inventory, changeset, reverse)
 
862
        if new_tree_path is None:
888
863
            continue
889
 
        new_path = os.path.join(dir, new_path)
890
 
        old_path = temp_name.get(entry.id)
 
864
        new_path = os.path.join(dir, new_tree_path)
 
865
        old_path = changed_inventory.get(entry.id)
891
866
        if os.path.exists(new_path):
892
867
            if conflict_handler.target_exists(entry, new_path, old_path) == \
893
868
                "skip":
894
869
                continue
895
870
        if entry.is_creation(reverse):
896
871
            entry.apply(new_path, conflict_handler, reverse)
 
872
            changed_inventory[entry.id] = new_tree_path
897
873
        else:
898
874
            if old_path is None:
899
875
                continue
900
876
            try:
901
877
                os.rename(old_path, new_path)
 
878
                changed_inventory[entry.id] = new_tree_path
902
879
            except OSError, e:
903
880
                raise Exception ("%s is missing" % new_path)
904
881
 
1006
983
        Exception.__init__(self, msg)
1007
984
        self.filename = filename
1008
985
 
 
986
class NewContentsConflict(Exception):
 
987
    def __init__(self, filename):
 
988
        msg = "Conflicting contents for new file %s" % (filename)
 
989
        Exception.__init__(self, msg)
 
990
 
 
991
 
 
992
class MissingForMerge(Exception):
 
993
    def __init__(self, filename):
 
994
        msg = "The file %s was modified, but does not exist in this tree"\
 
995
            % (filename)
 
996
        Exception.__init__(self, msg)
 
997
 
 
998
 
1009
999
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
    """
1010
1006
    def __init__(self, dir):
1011
1007
        self.dir = dir
1012
1008
    
1026
1022
    def rename_conflict(self, id, this_name, base_name, other_name):
1027
1023
        raise RenameConflict(id, this_name, base_name, other_name)
1028
1024
 
1029
 
    def move_conflict(self, id, inventory):
1030
 
        this_dir = inventory.this.get_dir(id)
1031
 
        base_dir = inventory.base.get_dir(id)
1032
 
        other_dir = inventory.other.get_dir(id)
 
1025
    def move_conflict(self, id, this_dir, base_dir, other_dir):
1033
1026
        raise MoveConflict(id, this_dir, base_dir, other_dir)
1034
1027
 
1035
 
    def merge_conflict(self, new_file, this_path, base_path, other_path):
 
1028
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1036
1029
        os.unlink(new_file)
1037
1030
        raise MergeConflict(this_path)
1038
1031
 
1066
1059
    def missing_for_rename(self, filename):
1067
1060
        raise MissingForRename(filename)
1068
1061
 
 
1062
    def missing_for_merge(self, file_id, other_path):
 
1063
        raise MissingForMerge(other_path)
 
1064
 
 
1065
    def new_contents_conflict(self, filename, other_contents):
 
1066
        raise NewContentsConflict(filename)
 
1067
 
 
1068
    def finalize(self):
 
1069
        pass
 
1070
 
1069
1071
def apply_changeset(changeset, inventory, dir, conflict_handler=None, 
1070
1072
                    reverse=False):
1071
1073
    """Apply a changeset to a directory.
1083
1085
    """
1084
1086
    if conflict_handler is None:
1085
1087
        conflict_handler = ExceptionConflictHandler(dir)
1086
 
    temp_dir = dir+"/temp"
1087
 
    os.mkdir(temp_dir)
 
1088
    temp_dir = os.path.join(dir, "bzr-tree-change")
 
1089
    try:
 
1090
        os.mkdir(temp_dir)
 
1091
    except OSError, e:
 
1092
        if e.errno == errno.EEXIST:
 
1093
            try:
 
1094
                os.rmdir(temp_dir)
 
1095
            except OSError, e:
 
1096
                if e.errno == errno.ENOTEMPTY:
 
1097
                    raise OldFailedTreeOp()
 
1098
            os.mkdir(temp_dir)
 
1099
        else:
 
1100
            raise
1088
1101
    
1089
1102
    #apply changes that don't affect filenames
1090
1103
    for entry in changeset.entries.itervalues():
1099
1112
    (source_entries, target_entries) = get_rename_entries(changeset, inventory,
1100
1113
                                                          reverse)
1101
1114
 
1102
 
    temp_name = rename_to_temp_delete(source_entries, inventory, dir,
1103
 
                                      conflict_handler, reverse)
 
1115
    changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
 
1116
                                              temp_dir, conflict_handler,
 
1117
                                              reverse)
1104
1118
 
1105
 
    rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
1106
 
                         conflict_handler, reverse)
 
1119
    rename_to_new_create(changed_inventory, target_entries, inventory,
 
1120
                         changeset, dir, conflict_handler, reverse)
1107
1121
    os.rmdir(temp_dir)
1108
 
    r_inventory = invert_dict(inventory)
1109
 
    new_entries, removed_entries = get_inventory_change(inventory,
1110
 
    r_inventory, changeset, reverse)
1111
 
    new_inventory = {}
1112
 
    for path, file_id in new_entries.iteritems():
1113
 
        new_inventory[file_id] = path
1114
 
    for file_id in removed_entries:
1115
 
        new_inventory[file_id] = None
1116
 
    return new_inventory
 
1122
    return changed_inventory
1117
1123
 
1118
1124
 
1119
1125
def apply_changeset_tree(cset, tree, reverse=False):
1130
1136
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1131
1137
    new_entries = {}
1132
1138
    remove_entries = []
1133
 
    r_inventory = invert_dict(inventory)
1134
 
    r_new_inventory = invert_dict(new_inventory)
1135
1139
    for entry in cset.entries.itervalues():
1136
1140
        if entry.needs_rename():
1137
 
            old_path = r_inventory.get(entry.id)
1138
 
            if old_path is not None:
1139
 
                remove_entries.append(old_path)
 
1141
            new_path = entry.get_new_path(inventory, cset)
 
1142
            if new_path is None:
 
1143
                remove_entries.append(entry.id)
1140
1144
            else:
1141
 
                new_path = entry.get_new_path(inventory, cset)
1142
 
                if new_path is not None:
1143
 
                    new_entries[new_path] = entry.id
 
1145
                new_entries[new_path] = entry.id
1144
1146
    return new_entries, remove_entries
1145
1147
 
1146
1148
 
1285
1287
        self.full_path = full_path
1286
1288
        self.stat_result = stat_result
1287
1289
 
1288
 
def generate_changeset(tree_a, tree_b, inventory_a=None, inventory_b=None):
1289
 
    return ChangesetGenerator(tree_a, tree_b, inventory_a, inventory_b)()
 
1290
def generate_changeset(tree_a, tree_b, interesting_ids=None):
 
1291
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1290
1292
 
1291
1293
class ChangesetGenerator(object):
1292
 
    def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
 
1294
    def __init__(self, tree_a, tree_b, interesting_ids=None):
1293
1295
        object.__init__(self)
1294
1296
        self.tree_a = tree_a
1295
1297
        self.tree_b = tree_b
1296
 
        if inventory_a is not None:
1297
 
            self.inventory_a = inventory_a
1298
 
        else:
1299
 
            self.inventory_a = tree_a.inventory()
1300
 
        if inventory_b is not None:
1301
 
            self.inventory_b = inventory_b
1302
 
        else:
1303
 
            self.inventory_b = tree_b.inventory()
1304
 
        self.r_inventory_a = self.reverse_inventory(self.inventory_a)
1305
 
        self.r_inventory_b = self.reverse_inventory(self.inventory_b)
 
1298
        self._interesting_ids = interesting_ids
1306
1299
 
1307
 
    def reverse_inventory(self, inventory):
1308
 
        r_inventory = {}
1309
 
        for entry in inventory.itervalues():
1310
 
            if entry.id is None:
1311
 
                continue
1312
 
            r_inventory[entry.id] = entry
1313
 
        return r_inventory
 
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
1314
1306
 
1315
1307
    def __call__(self):
1316
1308
        cset = Changeset()
1317
 
        for entry in self.inventory_a.itervalues():
1318
 
            if entry.id is None:
1319
 
                continue
1320
 
            cs_entry = self.make_entry(entry.id)
 
1309
        for file_id in self.iter_both_tree_ids():
 
1310
            cs_entry = self.make_entry(file_id)
1321
1311
            if cs_entry is not None and not cs_entry.is_boring():
1322
1312
                cset.add_entry(cs_entry)
1323
1313
 
1324
 
        for entry in self.inventory_b.itervalues():
1325
 
            if entry.id is None:
1326
 
                continue
1327
 
            if not self.r_inventory_a.has_key(entry.id):
1328
 
                cs_entry = self.make_entry(entry.id)
1329
 
                if cs_entry is not None and not cs_entry.is_boring():
1330
 
                    cset.add_entry(cs_entry)
1331
1314
        for entry in list(cset.entries.itervalues()):
1332
1315
            if entry.parent != entry.new_parent:
1333
1316
                if not cset.entries.has_key(entry.parent) and\
1341
1324
                    cset.add_entry(parent_entry)
1342
1325
        return cset
1343
1326
 
1344
 
    def get_entry_parent(self, entry, inventory):
1345
 
        if entry is None:
1346
 
            return None
1347
 
        if entry.path == "./.":
1348
 
            return NULL_ID
1349
 
        dirname = os.path.dirname(entry.path)
1350
 
        if dirname == ".":
1351
 
            dirname = "./."
1352
 
        parent = inventory[dirname]
1353
 
        return parent.id
1354
 
 
1355
 
    def get_paths(self, entry, tree):
1356
 
        if entry is None:
1357
 
            return (None, None)
1358
 
        full_path = tree.readonly_path(entry.id)
1359
 
        if entry.path == ".":
1360
 
            return ("", full_path)
1361
 
        return (entry.path, full_path)
1362
 
 
1363
 
    def make_basic_entry(self, id, only_interesting):
1364
 
        entry_a = self.r_inventory_a.get(id)
1365
 
        entry_b = self.r_inventory_b.get(id)
 
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)
1366
1353
        if only_interesting and not self.is_interesting(entry_a, entry_b):
1367
 
            return (None, None, None)
1368
 
        parent = self.get_entry_parent(entry_a, self.inventory_a)
1369
 
        (path, full_path_a) = self.get_paths(entry_a, self.tree_a)
1370
 
        cs_entry = ChangesetEntry(id, parent, path)
1371
 
        new_parent = self.get_entry_parent(entry_b, self.inventory_b)
1372
 
 
1373
 
 
1374
 
        (new_path, full_path_b) = self.get_paths(entry_b, self.tree_b)
 
1354
            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)
1375
1361
 
1376
1362
        cs_entry.new_path = new_path
1377
1363
        cs_entry.new_parent = new_parent
1378
 
        return (cs_entry, full_path_a, full_path_b)
 
1364
        return cs_entry
1379
1365
 
1380
1366
    def is_interesting(self, entry_a, entry_b):
 
1367
        if self._interesting_ids is None:
 
1368
            return True
1381
1369
        if entry_a is not None:
1382
 
            if entry_a.interesting:
1383
 
                return True
1384
 
        if entry_b is not None:
1385
 
            if entry_b.interesting:
1386
 
                return True
1387
 
        return False
 
1370
            file_id = entry_a.file_id
 
1371
        elif entry_b is not None:
 
1372
            file_id = entry_b.file_id
 
1373
        else:
 
1374
            return False
 
1375
        return file_id in self._interesting_ids
1388
1376
 
1389
1377
    def make_boring_entry(self, id):
1390
 
        (cs_entry, full_path_a, full_path_b) = \
1391
 
            self.make_basic_entry(id, only_interesting=False)
 
1378
        cs_entry = self.make_basic_entry(id, only_interesting=False)
1392
1379
        if cs_entry.is_creation_or_deletion():
1393
1380
            return self.make_entry(id, only_interesting=False)
1394
1381
        else:
1396
1383
        
1397
1384
 
1398
1385
    def make_entry(self, id, only_interesting=True):
1399
 
        (cs_entry, full_path_a, full_path_b) = \
1400
 
            self.make_basic_entry(id, only_interesting)
 
1386
        cs_entry = self.make_basic_entry(id, only_interesting)
1401
1387
 
1402
1388
        if cs_entry is None:
1403
1389
            return None
1404
 
       
 
1390
        if id in self.tree_a and id in self.tree_b:
 
1391
            a_sha1 = self.tree_a.get_file_sha1(id)
 
1392
            b_sha1 = self.tree_b.get_file_sha1(id)
 
1393
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
 
1394
                return cs_entry
 
1395
 
 
1396
        full_path_a = self.tree_a.readonly_path(id)
 
1397
        full_path_b = self.tree_b.readonly_path(id)
1405
1398
        stat_a = self.lstat(full_path_a)
1406
1399
        stat_b = self.lstat(full_path_b)
1407
 
        if stat_b is None:
1408
 
            cs_entry.new_parent = None
1409
 
            cs_entry.new_path = None
1410
1400
        
1411
1401
        cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1412
1402
        cs_entry.contents_change = self.make_contents_change(full_path_a,
1437
1427
            if stat_a.st_ino == stat_b.st_ino and \
1438
1428
                stat_a.st_dev == stat_b.st_dev:
1439
1429
                return None
1440
 
            if file(full_path_a, "rb").read() == \
1441
 
                file(full_path_b, "rb").read():
1442
 
                return None
1443
 
 
1444
 
            patch_contents = patch.diff(full_path_a, 
1445
 
                                        file(full_path_b, "rb").read())
1446
 
            if patch_contents is None:
1447
 
                return None
1448
 
            return PatchApply(patch_contents)
1449
1430
 
1450
1431
        a_contents = self.get_contents(stat_a, full_path_a)
1451
1432
        b_contents = self.get_contents(stat_b, full_path_b)
1499
1480
 
1500
1481
 
1501
1482
        
1502
 
    
 
1483
# XXX: Can't we unify this with the regular inventory object
1503
1484
class Inventory(object):
1504
1485
    def __init__(self, inventory):
1505
1486
        self.inventory = inventory
1514
1495
        return self.inventory.get(id)
1515
1496
 
1516
1497
    def get_name(self, id):
1517
 
        return os.path.basename(self.get_path(id))
 
1498
        path = self.get_path(id)
 
1499
        if path is None:
 
1500
            return None
 
1501
        else:
 
1502
            return os.path.basename(path)
1518
1503
 
1519
1504
    def get_dir(self, id):
1520
1505
        path = self.get_path(id)
1521
1506
        if path == "":
1522
1507
            return None
 
1508
        if path is None:
 
1509
            return None
1523
1510
        return os.path.dirname(path)
1524
1511
 
1525
1512
    def get_parent(self, id):
 
1513
        if self.get_path(id) is None:
 
1514
            return None
1526
1515
        directory = self.get_dir(id)
1527
1516
        if directory == '.':
1528
1517
            directory = './.'