« back to all changes in this revision
Viewing changes to bzrlib/changeset.py
- browse files at revision 1418
- compare with another revision
- download diff
- download tarball
- view history from revision 1418
- Committer: Robert Collins
- Date: 2005-10-06 12:14:01 UTC
- mfrom: (1393.1.67)
- Revision ID: robertc@robertcollins.net-20051006121401-ce87bcb93909bbdf
merge martins latest
- files added:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- patches
- tools
- files removed:
- bzrlib/remotebranch.py
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/urlgrabber/
- contrib/bash/bzr => contrib/bash/bzr.simple
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
added
removed
bzrlib/changeset.py
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
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
23
33
__docformat__ = "restructuredtext"
24
34
25
35
NULL_ID = "!NULL"
26
36
27
37
class OldFailedTreeOp(Exception):
38
def __init__(self):
39
Exception.__init__(self, "bzr-tree-change contains files from a"
40
" previous failed merge operation.")
28
41
def invert_dict(dict):
29
42
newdict = {}
30
43
for (key,value) in dict.iteritems():
31
44
newdict[value] = key
32
45
return newdict
33
46
34
35
class PatchApply:
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
84
class ChangeUnixPermissions:
47
48
class ChangeUnixPermissions(object):
85
49
"""This is two-way change, suitable for file modification, creation,
86
50
deletion"""
87
51
def __init__(self, old_mode, new_mode):
129
93
def __ne__(self, other):
130
94
return not (self == other)
131
95
96
132
97
def dir_create(filename, conflict_handler, reverse):
133
98
"""Creates the directory, or deletes it if reverse is true. Intended to be
134
99
used with ReplaceContents.
154
119
try:
155
120
os.rmdir(filename)
156
121
except OSError, e:
157
if e.errno != 39:
122
if e.errno != errno.ENOTEMPTY:
158
123
raise
159
124
if conflict_handler.rmdir_non_empty(filename) == "skip":
160
125
return
161
126
os.rmdir(filename)
162
127
163
164
165
128
166
class SymlinkCreate:
129
class SymlinkCreate(object):
167
130
"""Creates or deletes a symlink (for use with ReplaceContents)"""
168
131
def __init__(self, contents):
169
132
"""Constructor.
202
165
def __ne__(self, other):
203
166
return not (self == other)
204
167
205
class FileCreate:
168
class FileCreate(object):
206
169
"""Create or delete a file (for use with ReplaceContents)"""
207
170
def __init__(self, contents):
208
171
"""Constructor
265
228
for i in range(len(sequence)):
266
229
yield sequence[max - i]
267
230
268
class ReplaceContents:
231
class ReplaceContents(object):
269
232
"""A contents-replacement framework. It allows a file/directory/symlink to
270
233
be created, deleted, or replaced with another file/directory/symlink.
271
234
Arguments must be callable with (filename, reverse).
332
295
if mode is not None:
333
296
os.chmod(filename, mode)
334
297
335
class ApplySequence:
298
class ApplySequence(object):
336
299
def __init__(self, changes=None):
337
300
self.changes = []
338
301
if changes is not None:
362
325
change.apply(filename, conflict_handler, reverse)
363
326
364
327
365
class Diff3Merge:
366
def __init__(self, base_file, other_file):
367
self.base_file = base_file
368
self.other_file = other_file
328
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
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)
390
os.rename(new_file, filename)
356
rename(new_file, filename)
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:
762
737
Exception.__init__(self, msg)
763
738
self.id = id
764
739
765
class Changeset:
740
class Changeset(object):
766
741
"""A set of changes to apply"""
767
742
def __init__(self):
768
743
self.entries = {}
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)
858
833
try:
859
os.rename(src_path, to_name)
834
rename(src_path, to_name)
860
835
temp_name[entry.id] = to_name
861
836
except OSError, e:
862
837
if e.errno != errno.ENOENT:
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)
891
if os.path.exists(new_path):
864
new_path = os.path.join(dir, new_tree_path)
865
old_path = changed_inventory.get(entry.id)
866
if bzrlib.osutils.lexists(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
os.rename(old_path, new_path)
877
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
1009
class ExceptionConflictHandler:
1010
def __init__(self, dir):
1011
self.dir = dir
1012
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
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
"""
1013
1006
def missing_parent(self, pathname):
1014
1007
parent = os.path.dirname(pathname)
1015
1008
raise Exception("Parent directory missing for %s" % pathname)
1026
1019
def rename_conflict(self, id, this_name, base_name, other_name):
1027
1020
raise RenameConflict(id, this_name, base_name, other_name)
1028
1021
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)
1022
def move_conflict(self, id, this_dir, base_dir, other_dir):
1033
1023
raise MoveConflict(id, this_dir, base_dir, other_dir)
1034
1024
1035
def merge_conflict(self, new_file, this_path, base_path, other_path):
1025
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1036
1026
os.unlink(new_file)
1037
1027
raise MergeConflict(this_path)
1038
1028
1066
1056
def missing_for_rename(self, filename):
1067
1057
raise MissingForRename(filename)
1068
1058
1059
def missing_for_merge(self, file_id, other_path):
1060
raise MissingForMerge(other_path)
1061
1062
def new_contents_conflict(self, filename, other_contents):
1063
raise NewContentsConflict(filename)
1064
1065
def finalize(self):
1066
pass
1067
1069
1068
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1070
1069
reverse=False):
1071
1070
"""Apply a changeset to a directory.
1082
1081
:rtype: Dictionary
1083
1082
"""
1084
1083
if conflict_handler is None:
1085
conflict_handler = ExceptionConflictHandler(dir)
1086
temp_dir = dir+"/temp"
1087
os.mkdir(temp_dir)
1084
conflict_handler = ExceptionConflictHandler()
1085
temp_dir = os.path.join(dir, "bzr-tree-change")
1086
try:
1087
os.mkdir(temp_dir)
1088
except OSError, e:
1089
if e.errno == errno.EEXIST:
1090
try:
1091
os.rmdir(temp_dir)
1092
except OSError, e:
1093
if e.errno == errno.ENOTEMPTY:
1094
raise OldFailedTreeOp()
1095
os.mkdir(temp_dir)
1096
else:
1097
raise
1088
1098
1089
1099
#apply changes that don't affect filenames
1090
1100
for entry in changeset.entries.itervalues():
1099
1109
(source_entries, target_entries) = get_rename_entries(changeset, inventory,
1100
1110
reverse)
1101
1111
1102
temp_name = rename_to_temp_delete(source_entries, inventory, dir,
1103
conflict_handler, reverse)
1112
changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
1113
temp_dir, conflict_handler,
1114
reverse)
1104
1115
1105
rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
1106
conflict_handler, reverse)
1116
rename_to_new_create(changed_inventory, target_entries, inventory,
1117
changeset, dir, conflict_handler, reverse)
1107
1118
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
1119
return changed_inventory
1117
1120
1118
1121
1119
1122
def apply_changeset_tree(cset, tree, reverse=False):
1130
1133
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1131
1134
new_entries = {}
1132
1135
remove_entries = []
1133
r_inventory = invert_dict(inventory)
1134
r_new_inventory = invert_dict(new_inventory)
1135
1136
for entry in cset.entries.itervalues():
1136
1137
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)
1138
new_path = entry.get_new_path(inventory, cset)
1139
if new_path is None:
1140
remove_entries.append(entry.id)
1140
1141
else:
1141
new_path = entry.get_new_path(inventory, cset)
1142
if new_path is not None:
1143
new_entries[new_path] = entry.id
1142
new_entries[new_path] = entry.id
1144
1143
return new_entries, remove_entries
1145
1144
1146
1145
1285
1284
self.full_path = full_path
1286
1285
self.stat_result = stat_result
1287
1286
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)()
1287
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1288
return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1290
1289
1291
1290
class ChangesetGenerator(object):
1292
def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
1291
def __init__(self, tree_a, tree_b, interesting_ids=None):
1293
1292
object.__init__(self)
1294
1293
self.tree_a = tree_a
1295
1294
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)
1295
self._interesting_ids = interesting_ids
1306
1296
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
1297
def iter_both_tree_ids(self):
1298
for file_id in self.tree_a:
1299
yield file_id
1300
for file_id in self.tree_b:
1301
if file_id not in self.tree_a:
1302
yield file_id
1314
1303
1315
1304
def __call__(self):
1316
1305
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)
1306
for file_id in self.iter_both_tree_ids():
1307
cs_entry = self.make_entry(file_id)
1321
1308
if cs_entry is not None and not cs_entry.is_boring():
1322
1309
cset.add_entry(cs_entry)
1323
1310
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
1311
for entry in list(cset.entries.itervalues()):
1332
1312
if entry.parent != entry.new_parent:
1333
1313
if not cset.entries.has_key(entry.parent) and\
1341
1321
cset.add_entry(parent_entry)
1342
1322
return cset
1343
1323
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)
1324
def iter_inventory(self, tree):
1325
for file_id in tree:
1326
yield self.get_entry(file_id, tree)
1327
1328
def get_entry(self, file_id, tree):
1329
if not tree.has_or_had_id(file_id):
1330
return None
1331
return tree.tree.inventory[file_id]
1332
1333
def get_entry_parent(self, entry):
1334
if entry is None:
1335
return None
1336
return entry.parent_id
1337
1338
def get_path(self, file_id, tree):
1339
if not tree.has_or_had_id(file_id):
1340
return None
1341
path = tree.id2path(file_id)
1342
if path == '':
1343
return './.'
1344
else:
1345
return path
1346
1347
def make_basic_entry(self, file_id, only_interesting):
1348
entry_a = self.get_entry(file_id, self.tree_a)
1349
entry_b = self.get_entry(file_id, self.tree_b)
1366
1350
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)
1351
return None
1352
parent = self.get_entry_parent(entry_a)
1353
path = self.get_path(file_id, self.tree_a)
1354
cs_entry = ChangesetEntry(file_id, parent, path)
1355
new_parent = self.get_entry_parent(entry_b)
1356
1357
new_path = self.get_path(file_id, self.tree_b)
1375
1358
1376
1359
cs_entry.new_path = new_path
1377
1360
cs_entry.new_parent = new_parent
1378
return (cs_entry, full_path_a, full_path_b)
1361
return cs_entry
1379
1362
1380
1363
def is_interesting(self, entry_a, entry_b):
1364
if self._interesting_ids is None:
1365
return True
1381
1366
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
1367
file_id = entry_a.file_id
1368
elif entry_b is not None:
1369
file_id = entry_b.file_id
1370
else:
1371
return False
1372
return file_id in self._interesting_ids
1388
1373
1389
1374
def make_boring_entry(self, id):
1390
(cs_entry, full_path_a, full_path_b) = \
1391
self.make_basic_entry(id, only_interesting=False)
1375
cs_entry = self.make_basic_entry(id, only_interesting=False)
1392
1376
if cs_entry.is_creation_or_deletion():
1393
1377
return self.make_entry(id, only_interesting=False)
1394
1378
else:
1396
1380
1397
1381
1398
1382
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)
1383
cs_entry = self.make_basic_entry(id, only_interesting)
1401
1384
1402
1385
if cs_entry is None:
1403
1386
return None
1404
1387
1388
full_path_a = self.tree_a.readonly_path(id)
1389
full_path_b = self.tree_b.readonly_path(id)
1405
1390
stat_a = self.lstat(full_path_a)
1406
1391
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
1392
1411
1393
cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1394
1395
if id in self.tree_a and id in self.tree_b:
1396
a_sha1 = self.tree_a.get_file_sha1(id)
1397
b_sha1 = self.tree_b.get_file_sha1(id)
1398
if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1399
return cs_entry
1400
1412
1401
cs_entry.contents_change = self.make_contents_change(full_path_a,
1413
1402
stat_a,
1414
1403
full_path_b,
1437
1426
if stat_a.st_ino == stat_b.st_ino and \
1438
1427
stat_a.st_dev == stat_b.st_dev:
1439
1428
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
1429
1450
1430
a_contents = self.get_contents(stat_a, full_path_a)
1451
1431
b_contents = self.get_contents(stat_b, full_path_b)
1499
1479
1500
1480
1501
1481
1502
1503
class Inventory:
1482
# XXX: Can't we unify this with the regular inventory object
1483
class Inventory(object):
1504
1484
def __init__(self, inventory):
1505
1485
self.inventory = inventory
1506
1486
self.rinventory = None
1514
1494
return self.inventory.get(id)
1515
1495
1516
1496
def get_name(self, id):
1517
return os.path.basename(self.get_path(id))
1497
path = self.get_path(id)
1498
if path is None:
1499
return None
1500
else:
1501
return os.path.basename(path)
1518
1502
1519
1503
def get_dir(self, id):
1520
1504
path = self.get_path(id)
1521
1505
if path == "":
1522
1506
return None
1507
if path is None:
1508
return None
1523
1509
return os.path.dirname(path)
1524
1510
1525
1511
def get_parent(self, id):
1512
if self.get_path(id) is None:
1513
return None
1526
1514
directory = self.get_dir(id)
1527
1515
if directory == '.':
1528
1516
directory = './.'
Loggerhead is a web-based interface for Breezy
Version: 2.0.1