« back to all changes in this revision
Viewing changes to bzrlib/changeset.py
- browse files at revision 493
- compare with another revision
- compare with revision 2532
- download diff
- download tarball
- view history from revision 493
- Committer: Martin Pool
- Date: 2005-05-15 02:36:04 UTC
- Revision ID: mbp@sourcefrog.net-20050515023603-7328f6cbabd2b09a
- Merge aaron's merge command
- files added:
- bzrlib/changeset.py
- files modified:
- bzrlib/add.py
added
removed
bzrlib/changeset.py
1
# Copyright (C) 2004 Aaron Bentley <aaron.bentley@utoronto.ca>
2
#
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
#
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
12
#
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
import os.path
17
import errno
18
import patch
19
import stat
20
"""
21
Represent and apply a changeset
22
"""
23
__docformat__ = "restructuredtext"
24
25
NULL_ID = "!NULL"
26
27
28
def invert_dict(dict):
29
newdict = {}
30
for (key,value) in dict.iteritems():
31
newdict[value] = key
32
return newdict
33
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:
85
"""This is two-way change, suitable for file modification, creation,
86
deletion"""
87
def __init__(self, old_mode, new_mode):
88
self.old_mode = old_mode
89
self.new_mode = new_mode
90
91
def apply(self, filename, conflict_handler, reverse=False):
92
if not reverse:
93
from_mode = self.old_mode
94
to_mode = self.new_mode
95
else:
96
from_mode = self.new_mode
97
to_mode = self.old_mode
98
try:
99
current_mode = os.stat(filename).st_mode &0777
100
except OSError, e:
101
if e.errno == errno.ENOENT:
102
if conflict_handler.missing_for_chmod(filename) == "skip":
103
return
104
else:
105
current_mode = from_mode
106
107
if from_mode is not None and current_mode != from_mode:
108
if conflict_handler.wrong_old_perms(filename, from_mode,
109
current_mode) != "continue":
110
return
111
112
if to_mode is not None:
113
try:
114
os.chmod(filename, to_mode)
115
except IOError, e:
116
if e.errno == errno.ENOENT:
117
conflict_handler.missing_for_chmod(filename)
118
119
def __eq__(self, other):
120
if not isinstance(other, ChangeUnixPermissions):
121
return False
122
elif self.old_mode != other.old_mode:
123
return False
124
elif self.new_mode != other.new_mode:
125
return False
126
else:
127
return True
128
129
def __ne__(self, other):
130
return not (self == other)
131
132
def dir_create(filename, conflict_handler, reverse):
133
"""Creates the directory, or deletes it if reverse is true. Intended to be
134
used with ReplaceContents.
135
136
:param filename: The name of the directory to create
137
:type filename: str
138
:param reverse: If true, delete the directory, instead
139
:type reverse: bool
140
"""
141
if not reverse:
142
try:
143
os.mkdir(filename)
144
except OSError, e:
145
if e.errno != errno.EEXIST:
146
raise
147
if conflict_handler.dir_exists(filename) == "continue":
148
os.mkdir(filename)
149
except IOError, e:
150
if e.errno == errno.ENOENT:
151
if conflict_handler.missing_parent(filename)=="continue":
152
file(filename, "wb").write(self.contents)
153
else:
154
try:
155
os.rmdir(filename)
156
except OSError, e:
157
if e.errno != 39:
158
raise
159
if conflict_handler.rmdir_non_empty(filename) == "skip":
160
return
161
os.rmdir(filename)
162
163
164
165
166
class SymlinkCreate:
167
"""Creates or deletes a symlink (for use with ReplaceContents)"""
168
def __init__(self, contents):
169
"""Constructor.
170
171
:param contents: The filename of the target the symlink should point to
172
:type contents: str
173
"""
174
self.target = contents
175
176
def __call__(self, filename, conflict_handler, reverse):
177
"""Creates or destroys the symlink.
178
179
:param filename: The name of the symlink to create
180
:type filename: str
181
"""
182
if reverse:
183
assert(os.readlink(filename) == self.target)
184
os.unlink(filename)
185
else:
186
try:
187
os.symlink(self.target, filename)
188
except OSError, e:
189
if e.errno != errno.EEXIST:
190
raise
191
if conflict_handler.link_name_exists(filename) == "continue":
192
os.symlink(self.target, filename)
193
194
def __eq__(self, other):
195
if not isinstance(other, SymlinkCreate):
196
return False
197
elif self.target != other.target:
198
return False
199
else:
200
return True
201
202
def __ne__(self, other):
203
return not (self == other)
204
205
class FileCreate:
206
"""Create or delete a file (for use with ReplaceContents)"""
207
def __init__(self, contents):
208
"""Constructor
209
210
:param contents: The contents of the file to write
211
:type contents: str
212
"""
213
self.contents = contents
214
215
def __repr__(self):
216
return "FileCreate(%i b)" % len(self.contents)
217
218
def __eq__(self, other):
219
if not isinstance(other, FileCreate):
220
return False
221
elif self.contents != other.contents:
222
return False
223
else:
224
return True
225
226
def __ne__(self, other):
227
return not (self == other)
228
229
def __call__(self, filename, conflict_handler, reverse):
230
"""Create or delete a file
231
232
:param filename: The name of the file to create
233
:type filename: str
234
:param reverse: Delete the file instead of creating it
235
:type reverse: bool
236
"""
237
if not reverse:
238
try:
239
file(filename, "wb").write(self.contents)
240
except IOError, e:
241
if e.errno == errno.ENOENT:
242
if conflict_handler.missing_parent(filename)=="continue":
243
file(filename, "wb").write(self.contents)
244
else:
245
raise
246
247
else:
248
try:
249
if (file(filename, "rb").read() != self.contents):
250
direction = conflict_handler.wrong_old_contents(filename,
251
self.contents)
252
if direction != "continue":
253
return
254
os.unlink(filename)
255
except IOError, e:
256
if e.errno != errno.ENOENT:
257
raise
258
if conflict_handler.missing_for_rm(filename, undo) == "skip":
259
return
260
261
262
263
def reversed(sequence):
264
max = len(sequence) - 1
265
for i in range(len(sequence)):
266
yield sequence[max - i]
267
268
class ReplaceContents:
269
"""A contents-replacement framework. It allows a file/directory/symlink to
270
be created, deleted, or replaced with another file/directory/symlink.
271
Arguments must be callable with (filename, reverse).
272
"""
273
def __init__(self, old_contents, new_contents):
274
"""Constructor.
275
276
:param old_contents: The change to reverse apply (e.g. a deletion), \
277
when going forwards.
278
:type old_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
279
NoneType, etc.
280
:param new_contents: The second change to apply (e.g. a creation), \
281
when going forwards.
282
:type new_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
283
NoneType, etc.
284
"""
285
self.old_contents=old_contents
286
self.new_contents=new_contents
287
288
def __repr__(self):
289
return "ReplaceContents(%r -> %r)" % (self.old_contents,
290
self.new_contents)
291
292
def __eq__(self, other):
293
if not isinstance(other, ReplaceContents):
294
return False
295
elif self.old_contents != other.old_contents:
296
return False
297
elif self.new_contents != other.new_contents:
298
return False
299
else:
300
return True
301
def __ne__(self, other):
302
return not (self == other)
303
304
def apply(self, filename, conflict_handler, reverse=False):
305
"""Applies the FileReplacement to the specified filename
306
307
:param filename: The name of the file to apply changes to
308
:type filename: str
309
:param reverse: If true, apply the change in reverse
310
:type reverse: bool
311
"""
312
if not reverse:
313
undo = self.old_contents
314
perform = self.new_contents
315
else:
316
undo = self.new_contents
317
perform = self.old_contents
318
mode = None
319
if undo is not None:
320
try:
321
mode = os.lstat(filename).st_mode
322
if stat.S_ISLNK(mode):
323
mode = None
324
except OSError, e:
325
if e.errno != errno.ENOENT:
326
raise
327
if conflict_handler.missing_for_rm(filename, undo) == "skip":
328
return
329
undo(filename, conflict_handler, reverse=True)
330
if perform is not None:
331
perform(filename, conflict_handler, reverse=False)
332
if mode is not None:
333
os.chmod(filename, mode)
334
335
class ApplySequence:
336
def __init__(self, changes=None):
337
self.changes = []
338
if changes is not None:
339
self.changes.extend(changes)
340
341
def __eq__(self, other):
342
if not isinstance(other, ApplySequence):
343
return False
344
elif len(other.changes) != len(self.changes):
345
return False
346
else:
347
for i in range(len(self.changes)):
348
if self.changes[i] != other.changes[i]:
349
return False
350
return True
351
352
def __ne__(self, other):
353
return not (self == other)
354
355
356
def apply(self, filename, conflict_handler, reverse=False):
357
if not reverse:
358
iter = self.changes
359
else:
360
iter = reversed(self.changes)
361
for change in iter:
362
change.apply(filename, conflict_handler, reverse)
363
364
365
class Diff3Merge:
366
def __init__(self, base_file, other_file):
367
self.base_file = base_file
368
self.other_file = other_file
369
370
def __eq__(self, other):
371
if not isinstance(other, Diff3Merge):
372
return False
373
return (self.base_file == other.base_file and
374
self.other_file == other.other_file)
375
376
def __ne__(self, other):
377
return not (self == other)
378
379
def apply(self, filename, conflict_handler, reverse=False):
380
new_file = filename+".new"
381
if not reverse:
382
base = self.base_file
383
other = self.other_file
384
else:
385
base = self.other_file
386
other = self.base_file
387
status = patch.diff3(new_file, filename, base, other)
388
if status == 0:
389
os.chmod(new_file, os.stat(filename).st_mode)
390
os.rename(new_file, filename)
391
return
392
else:
393
assert(status == 1)
394
conflict_handler.merge_conflict(new_file, filename, base, other)
395
396
397
def CreateDir():
398
"""Convenience function to create a directory.
399
400
:return: A ReplaceContents that will create a directory
401
:rtype: `ReplaceContents`
402
"""
403
return ReplaceContents(None, dir_create)
404
405
def DeleteDir():
406
"""Convenience function to delete a directory.
407
408
:return: A ReplaceContents that will delete a directory
409
:rtype: `ReplaceContents`
410
"""
411
return ReplaceContents(dir_create, None)
412
413
def CreateFile(contents):
414
"""Convenience fucntion to create a file.
415
416
:param contents: The contents of the file to create
417
:type contents: str
418
:return: A ReplaceContents that will create a file
419
:rtype: `ReplaceContents`
420
"""
421
return ReplaceContents(None, FileCreate(contents))
422
423
def DeleteFile(contents):
424
"""Convenience fucntion to delete a file.
425
426
:param contents: The contents of the file to delete
427
:type contents: str
428
:return: A ReplaceContents that will delete a file
429
:rtype: `ReplaceContents`
430
"""
431
return ReplaceContents(FileCreate(contents), None)
432
433
def ReplaceFileContents(old_contents, new_contents):
434
"""Convenience fucntion to replace the contents of a file.
435
436
:param old_contents: The contents of the file to replace
437
:type old_contents: str
438
:param new_contents: The contents to replace the file with
439
:type new_contents: str
440
:return: A ReplaceContents that will replace the contents of a file a file
441
:rtype: `ReplaceContents`
442
"""
443
return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
444
445
def CreateSymlink(target):
446
"""Convenience fucntion to create a symlink.
447
448
:param target: The path the link should point to
449
:type target: str
450
:return: A ReplaceContents that will delete a file
451
:rtype: `ReplaceContents`
452
"""
453
return ReplaceContents(None, SymlinkCreate(target))
454
455
def DeleteSymlink(target):
456
"""Convenience fucntion to delete a symlink.
457
458
:param target: The path the link should point to
459
:type target: str
460
:return: A ReplaceContents that will delete a file
461
:rtype: `ReplaceContents`
462
"""
463
return ReplaceContents(SymlinkCreate(target), None)
464
465
def ChangeTarget(old_target, new_target):
466
"""Convenience fucntion to change the target of a symlink.
467
468
:param old_target: The current link target
469
:type old_target: str
470
:param new_target: The new link target to use
471
:type new_target: str
472
:return: A ReplaceContents that will delete a file
473
:rtype: `ReplaceContents`
474
"""
475
return ReplaceContents(SymlinkCreate(old_target), SymlinkCreate(new_target))
476
477
478
class InvalidEntry(Exception):
479
"""Raise when a ChangesetEntry is invalid in some way"""
480
def __init__(self, entry, problem):
481
"""Constructor.
482
483
:param entry: The invalid ChangesetEntry
484
:type entry: `ChangesetEntry`
485
:param problem: The problem with the entry
486
:type problem: str
487
"""
488
msg = "Changeset entry for %s (%s) is invalid.\n%s" % (entry.id,
489
entry.path,
490
problem)
491
Exception.__init__(self, msg)
492
self.entry = entry
493
494
495
class SourceRootHasName(InvalidEntry):
496
"""This changeset entry has a name other than "", but its parent is !NULL"""
497
def __init__(self, entry, name):
498
"""Constructor.
499
500
:param entry: The invalid ChangesetEntry
501
:type entry: `ChangesetEntry`
502
:param name: The name of the entry
503
:type name: str
504
"""
505
msg = 'Child of !NULL is named "%s", not "./.".' % name
506
InvalidEntry.__init__(self, entry, msg)
507
508
class NullIDAssigned(InvalidEntry):
509
"""The id !NULL was assigned to a real entry"""
510
def __init__(self, entry):
511
"""Constructor.
512
513
:param entry: The invalid ChangesetEntry
514
:type entry: `ChangesetEntry`
515
"""
516
msg = '"!NULL" id assigned to a file "%s".' % entry.path
517
InvalidEntry.__init__(self, entry, msg)
518
519
class ParentIDIsSelf(InvalidEntry):
520
"""An entry is marked as its own parent"""
521
def __init__(self, entry):
522
"""Constructor.
523
524
:param entry: The invalid ChangesetEntry
525
:type entry: `ChangesetEntry`
526
"""
527
msg = 'file %s has "%s" id for both self id and parent id.' % \
528
(entry.path, entry.id)
529
InvalidEntry.__init__(self, entry, msg)
530
531
class ChangesetEntry(object):
532
"""An entry the changeset"""
533
def __init__(self, id, parent, path):
534
"""Constructor. Sets parent and name assuming it was not
535
renamed/created/deleted.
536
:param id: The id associated with the entry
537
:param parent: The id of the parent of this entry (or !NULL if no
538
parent)
539
:param path: The file path relative to the tree root of this entry
540
"""
541
self.id = id
542
self.path = path
543
self.new_path = path
544
self.parent = parent
545
self.new_parent = parent
546
self.contents_change = None
547
self.metadata_change = None
548
if parent == NULL_ID and path !='./.':
549
raise SourceRootHasName(self, path)
550
if self.id == NULL_ID:
551
raise NullIDAssigned(self)
552
if self.id == self.parent:
553
raise ParentIDIsSelf(self)
554
555
def __str__(self):
556
return "ChangesetEntry(%s)" % self.id
557
558
def __get_dir(self):
559
if self.path is None:
560
return None
561
return os.path.dirname(self.path)
562
563
def __set_dir(self, dir):
564
self.path = os.path.join(dir, os.path.basename(self.path))
565
566
dir = property(__get_dir, __set_dir)
567
568
def __get_name(self):
569
if self.path is None:
570
return None
571
return os.path.basename(self.path)
572
573
def __set_name(self, name):
574
self.path = os.path.join(os.path.dirname(self.path), name)
575
576
name = property(__get_name, __set_name)
577
578
def __get_new_dir(self):
579
if self.new_path is None:
580
return None
581
return os.path.dirname(self.new_path)
582
583
def __set_new_dir(self, dir):
584
self.new_path = os.path.join(dir, os.path.basename(self.new_path))
585
586
new_dir = property(__get_new_dir, __set_new_dir)
587
588
def __get_new_name(self):
589
if self.new_path is None:
590
return None
591
return os.path.basename(self.new_path)
592
593
def __set_new_name(self, name):
594
self.new_path = os.path.join(os.path.dirname(self.new_path), name)
595
596
new_name = property(__get_new_name, __set_new_name)
597
598
def needs_rename(self):
599
"""Determines whether the entry requires renaming.
600
601
:rtype: bool
602
"""
603
604
return (self.parent != self.new_parent or self.name != self.new_name)
605
606
def is_deletion(self, reverse):
607
"""Return true if applying the entry would delete a file/directory.
608
609
:param reverse: if true, the changeset is being applied in reverse
610
:rtype: bool
611
"""
612
return ((self.new_parent is None and not reverse) or
613
(self.parent is None and reverse))
614
615
def is_creation(self, reverse):
616
"""Return true if applying the entry would create a file/directory.
617
618
:param reverse: if true, the changeset is being applied in reverse
619
:rtype: bool
620
"""
621
return ((self.parent is None and not reverse) or
622
(self.new_parent is None and reverse))
623
624
def is_creation_or_deletion(self):
625
"""Return true if applying the entry would create or delete a
626
file/directory.
627
628
:rtype: bool
629
"""
630
return self.parent is None or self.new_parent is None
631
632
def get_cset_path(self, mod=False):
633
"""Determine the path of the entry according to the changeset.
634
635
:param changeset: The changeset to derive the path from
636
:type changeset: `Changeset`
637
:param mod: If true, generate the MOD path. Otherwise, generate the \
638
ORIG path.
639
:return: the path of the entry, or None if it did not exist in the \
640
requested tree.
641
:rtype: str or NoneType
642
"""
643
if mod:
644
if self.new_parent == NULL_ID:
645
return "./."
646
elif self.new_parent is None:
647
return None
648
return self.new_path
649
else:
650
if self.parent == NULL_ID:
651
return "./."
652
elif self.parent is None:
653
return None
654
return self.path
655
656
def summarize_name(self, changeset, reverse=False):
657
"""Produce a one-line summary of the filename. Indicates renames as
658
old => new, indicates creation as None => new, indicates deletion as
659
old => None.
660
661
:param changeset: The changeset to get paths from
662
:type changeset: `Changeset`
663
:param reverse: If true, reverse the names in the output
664
:type reverse: bool
665
:rtype: str
666
"""
667
orig_path = self.get_cset_path(False)
668
mod_path = self.get_cset_path(True)
669
if orig_path is not None:
670
orig_path = orig_path[2:]
671
if mod_path is not None:
672
mod_path = mod_path[2:]
673
if orig_path == mod_path:
674
return orig_path
675
else:
676
if not reverse:
677
return "%s => %s" % (orig_path, mod_path)
678
else:
679
return "%s => %s" % (mod_path, orig_path)
680
681
682
def get_new_path(self, id_map, changeset, reverse=False):
683
"""Determine the full pathname to rename to
684
685
:param id_map: The map of ids to filenames for the tree
686
:type id_map: Dictionary
687
:param changeset: The changeset to get data from
688
:type changeset: `Changeset`
689
:param reverse: If true, we're applying the changeset in reverse
690
:type reverse: bool
691
:rtype: str
692
"""
693
if reverse:
694
parent = self.parent
695
to_dir = self.dir
696
from_dir = self.new_dir
697
to_name = self.name
698
from_name = self.new_name
699
else:
700
parent = self.new_parent
701
to_dir = self.new_dir
702
from_dir = self.dir
703
to_name = self.new_name
704
from_name = self.name
705
706
if to_name is None:
707
return None
708
709
if parent == NULL_ID or parent is None:
710
if to_name != '.':
711
raise SourceRootHasName(self, to_name)
712
else:
713
return '.'
714
if from_dir == to_dir:
715
dir = os.path.dirname(id_map[self.id])
716
else:
717
parent_entry = changeset.entries[parent]
718
dir = parent_entry.get_new_path(id_map, changeset, reverse)
719
if from_name == to_name:
720
name = os.path.basename(id_map[self.id])
721
else:
722
name = to_name
723
assert(from_name is None or from_name == os.path.basename(id_map[self.id]))
724
return os.path.join(dir, name)
725
726
def is_boring(self):
727
"""Determines whether the entry does nothing
728
729
:return: True if the entry does no renames or content changes
730
:rtype: bool
731
"""
732
if self.contents_change is not None:
733
return False
734
elif self.metadata_change is not None:
735
return False
736
elif self.parent != self.new_parent:
737
return False
738
elif self.name != self.new_name:
739
return False
740
else:
741
return True
742
743
def apply(self, filename, conflict_handler, reverse=False):
744
"""Applies the file content and/or metadata changes.
745
746
:param filename: the filename of the entry
747
:type filename: str
748
:param reverse: If true, apply the changes in reverse
749
:type reverse: bool
750
"""
751
if self.is_deletion(reverse) and self.metadata_change is not None:
752
self.metadata_change.apply(filename, conflict_handler, reverse)
753
if self.contents_change is not None:
754
self.contents_change.apply(filename, conflict_handler, reverse)
755
if not self.is_deletion(reverse) and self.metadata_change is not None:
756
self.metadata_change.apply(filename, conflict_handler, reverse)
757
758
class IDPresent(Exception):
759
def __init__(self, id):
760
msg = "Cannot add entry because that id has already been used:\n%s" %\
761
id
762
Exception.__init__(self, msg)
763
self.id = id
764
765
class Changeset:
766
"""A set of changes to apply"""
767
def __init__(self):
768
self.entries = {}
769
770
def add_entry(self, entry):
771
"""Add an entry to the list of entries"""
772
if self.entries.has_key(entry.id):
773
raise IDPresent(entry.id)
774
self.entries[entry.id] = entry
775
776
def my_sort(sequence, key, reverse=False):
777
"""A sort function that supports supplying a key for comparison
778
779
:param sequence: The sequence to sort
780
:param key: A callable object that returns the values to be compared
781
:param reverse: If true, sort in reverse order
782
:type reverse: bool
783
"""
784
def cmp_by_key(entry_a, entry_b):
785
if reverse:
786
tmp=entry_a
787
entry_a = entry_b
788
entry_b = tmp
789
return cmp(key(entry_a), key(entry_b))
790
sequence.sort(cmp_by_key)
791
792
def get_rename_entries(changeset, inventory, reverse):
793
"""Return a list of entries that will be renamed. Entries are sorted from
794
longest to shortest source path and from shortest to longest target path.
795
796
:param changeset: The changeset to look in
797
:type changeset: `Changeset`
798
:param inventory: The source of current tree paths for the given ids
799
:type inventory: Dictionary
800
:param reverse: If true, the changeset is being applied in reverse
801
:type reverse: bool
802
:return: source entries and target entries as a tuple
803
:rtype: (List, List)
804
"""
805
source_entries = [x for x in changeset.entries.itervalues()
806
if x.needs_rename()]
807
# these are done from longest path to shortest, to avoid deleting a
808
# parent before its children are deleted/renamed
809
def longest_to_shortest(entry):
810
path = inventory.get(entry.id)
811
if path is None:
812
return 0
813
else:
814
return len(path)
815
my_sort(source_entries, longest_to_shortest, reverse=True)
816
817
target_entries = source_entries[:]
818
# These are done from shortest to longest path, to avoid creating a
819
# child before its parent has been created/renamed
820
def shortest_to_longest(entry):
821
path = entry.get_new_path(inventory, changeset, reverse)
822
if path is None:
823
return 0
824
else:
825
return len(path)
826
my_sort(target_entries, shortest_to_longest)
827
return (source_entries, target_entries)
828
829
def rename_to_temp_delete(source_entries, inventory, dir, conflict_handler,
830
reverse):
831
"""Delete and rename entries as appropriate. Entries are renamed to temp
832
names. A map of id -> temp name is returned.
833
834
:param source_entries: The entries to rename and delete
835
:type source_entries: List of `ChangesetEntry`
836
:param inventory: The map of id -> filename in the current tree
837
:type inventory: Dictionary
838
:param dir: The directory to apply changes to
839
:type dir: str
840
:param reverse: Apply changes in reverse
841
:type reverse: bool
842
:return: a mapping of id to temporary name
843
:rtype: Dictionary
844
"""
845
temp_dir = os.path.join(dir, "temp")
846
temp_name = {}
847
for i in range(len(source_entries)):
848
entry = source_entries[i]
849
if entry.is_deletion(reverse):
850
path = os.path.join(dir, inventory[entry.id])
851
entry.apply(path, conflict_handler, reverse)
852
853
else:
854
to_name = temp_dir+"/"+str(i)
855
src_path = inventory.get(entry.id)
856
if src_path is not None:
857
src_path = os.path.join(dir, src_path)
858
try:
859
os.rename(src_path, to_name)
860
temp_name[entry.id] = to_name
861
except OSError, e:
862
if e.errno != errno.ENOENT:
863
raise
864
if conflict_handler.missing_for_rename(src_path) == "skip":
865
continue
866
867
return temp_name
868
869
870
def rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
871
conflict_handler, reverse):
872
"""Rename entries with temp names to their final names, create new files.
873
874
:param temp_name: A mapping of id to temporary name
875
:type temp_name: Dictionary
876
:param target_entries: The entries to apply changes to
877
:type target_entries: List of `ChangesetEntry`
878
:param changeset: The changeset to apply
879
:type changeset: `Changeset`
880
:param dir: The directory to apply changes to
881
:type dir: str
882
:param reverse: If true, apply changes in reverse
883
:type reverse: bool
884
"""
885
for entry in target_entries:
886
new_path = entry.get_new_path(inventory, changeset, reverse)
887
if new_path is None:
888
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):
892
if conflict_handler.target_exists(entry, new_path, old_path) == \
893
"skip":
894
continue
895
if entry.is_creation(reverse):
896
entry.apply(new_path, conflict_handler, reverse)
897
else:
898
if old_path is None:
899
continue
900
try:
901
os.rename(old_path, new_path)
902
except OSError, e:
903
raise Exception ("%s is missing" % new_path)
904
905
class TargetExists(Exception):
906
def __init__(self, entry, target):
907
msg = "The path %s already exists" % target
908
Exception.__init__(self, msg)
909
self.entry = entry
910
self.target = target
911
912
class RenameConflict(Exception):
913
def __init__(self, id, this_name, base_name, other_name):
914
msg = """Trees all have different names for a file
915
this: %s
916
base: %s
917
other: %s
918
id: %s""" % (this_name, base_name, other_name, id)
919
Exception.__init__(self, msg)
920
self.this_name = this_name
921
self.base_name = base_name
922
self_other_name = other_name
923
924
class MoveConflict(Exception):
925
def __init__(self, id, this_parent, base_parent, other_parent):
926
msg = """The file is in different directories in every tree
927
this: %s
928
base: %s
929
other: %s
930
id: %s""" % (this_parent, base_parent, other_parent, id)
931
Exception.__init__(self, msg)
932
self.this_parent = this_parent
933
self.base_parent = base_parent
934
self_other_parent = other_parent
935
936
class MergeConflict(Exception):
937
def __init__(self, this_path):
938
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
939
self.this_path = this_path
940
941
class MergePermissionConflict(Exception):
942
def __init__(self, this_path, base_path, other_path):
943
this_perms = os.stat(this_path).st_mode & 0755
944
base_perms = os.stat(base_path).st_mode & 0755
945
other_perms = os.stat(other_path).st_mode & 0755
946
msg = """Conflicting permission for %s
947
this: %o
948
base: %o
949
other: %o
950
""" % (this_path, this_perms, base_perms, other_perms)
951
self.this_path = this_path
952
self.base_path = base_path
953
self.other_path = other_path
954
Exception.__init__(self, msg)
955
956
class WrongOldContents(Exception):
957
def __init__(self, filename):
958
msg = "Contents mismatch deleting %s" % filename
959
self.filename = filename
960
Exception.__init__(self, msg)
961
962
class WrongOldPermissions(Exception):
963
def __init__(self, filename, old_perms, new_perms):
964
msg = "Permission missmatch on %s:\n" \
965
"Expected 0%o, got 0%o." % (filename, old_perms, new_perms)
966
self.filename = filename
967
Exception.__init__(self, msg)
968
969
class RemoveContentsConflict(Exception):
970
def __init__(self, filename):
971
msg = "Conflict deleting %s, which has different contents in BASE"\
972
" and THIS" % filename
973
self.filename = filename
974
Exception.__init__(self, msg)
975
976
class DeletingNonEmptyDirectory(Exception):
977
def __init__(self, filename):
978
msg = "Trying to remove dir %s while it still had files" % filename
979
self.filename = filename
980
Exception.__init__(self, msg)
981
982
983
class PatchTargetMissing(Exception):
984
def __init__(self, filename):
985
msg = "Attempt to patch %s, which does not exist" % filename
986
Exception.__init__(self, msg)
987
self.filename = filename
988
989
class MissingPermsFile(Exception):
990
def __init__(self, filename):
991
msg = "Attempt to change permissions on %s, which does not exist" %\
992
filename
993
Exception.__init__(self, msg)
994
self.filename = filename
995
996
class MissingForRm(Exception):
997
def __init__(self, filename):
998
msg = "Attempt to remove missing path %s" % filename
999
Exception.__init__(self, msg)
1000
self.filename = filename
1001
1002
1003
class MissingForRename(Exception):
1004
def __init__(self, filename):
1005
msg = "Attempt to move missing path %s" % (filename)
1006
Exception.__init__(self, msg)
1007
self.filename = filename
1008
1009
class ExceptionConflictHandler:
1010
def __init__(self, dir):
1011
self.dir = dir
1012
1013
def missing_parent(self, pathname):
1014
parent = os.path.dirname(pathname)
1015
raise Exception("Parent directory missing for %s" % pathname)
1016
1017
def dir_exists(self, pathname):
1018
raise Exception("Directory already exists for %s" % pathname)
1019
1020
def failed_hunks(self, pathname):
1021
raise Exception("Failed to apply some hunks for %s" % pathname)
1022
1023
def target_exists(self, entry, target, old_path):
1024
raise TargetExists(entry, target)
1025
1026
def rename_conflict(self, id, this_name, base_name, other_name):
1027
raise RenameConflict(id, this_name, base_name, other_name)
1028
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)
1033
raise MoveConflict(id, this_dir, base_dir, other_dir)
1034
1035
def merge_conflict(self, new_file, this_path, base_path, other_path):
1036
os.unlink(new_file)
1037
raise MergeConflict(this_path)
1038
1039
def permission_conflict(self, this_path, base_path, other_path):
1040
raise MergePermissionConflict(this_path, base_path, other_path)
1041
1042
def wrong_old_contents(self, filename, expected_contents):
1043
raise WrongOldContents(filename)
1044
1045
def rem_contents_conflict(self, filename, this_contents, base_contents):
1046
raise RemoveContentsConflict(filename)
1047
1048
def wrong_old_perms(self, filename, old_perms, new_perms):
1049
raise WrongOldPermissions(filename, old_perms, new_perms)
1050
1051
def rmdir_non_empty(self, filename):
1052
raise DeletingNonEmptyDirectory(filename)
1053
1054
def link_name_exists(self, filename):
1055
raise TargetExists(filename)
1056
1057
def patch_target_missing(self, filename, contents):
1058
raise PatchTargetMissing(filename)
1059
1060
def missing_for_chmod(self, filename):
1061
raise MissingPermsFile(filename)
1062
1063
def missing_for_rm(self, filename, change):
1064
raise MissingForRm(filename)
1065
1066
def missing_for_rename(self, filename):
1067
raise MissingForRename(filename)
1068
1069
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1070
reverse=False):
1071
"""Apply a changeset to a directory.
1072
1073
:param changeset: The changes to perform
1074
:type changeset: `Changeset`
1075
:param inventory: The mapping of id to filename for the directory
1076
:type inventory: Dictionary
1077
:param dir: The path of the directory to apply the changes to
1078
:type dir: str
1079
:param reverse: If true, apply the changes in reverse
1080
:type reverse: bool
1081
:return: The mapping of the changed entries
1082
:rtype: Dictionary
1083
"""
1084
if conflict_handler is None:
1085
conflict_handler = ExceptionConflictHandler(dir)
1086
temp_dir = dir+"/temp"
1087
os.mkdir(temp_dir)
1088
1089
#apply changes that don't affect filenames
1090
for entry in changeset.entries.itervalues():
1091
if not entry.is_creation_or_deletion():
1092
path = os.path.join(dir, inventory[entry.id])
1093
entry.apply(path, conflict_handler, reverse)
1094
1095
# Apply renames in stages, to minimize conflicts:
1096
# Only files whose name or parent change are interesting, because their
1097
# target name may exist in the source tree. If a directory's name changes,
1098
# that doesn't make its children interesting.
1099
(source_entries, target_entries) = get_rename_entries(changeset, inventory,
1100
reverse)
1101
1102
temp_name = rename_to_temp_delete(source_entries, inventory, dir,
1103
conflict_handler, reverse)
1104
1105
rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
1106
conflict_handler, reverse)
1107
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
1117
1118
1119
def apply_changeset_tree(cset, tree, reverse=False):
1120
r_inventory = {}
1121
for entry in tree.source_inventory().itervalues():
1122
inventory[entry.id] = entry.path
1123
new_inventory = apply_changeset(cset, r_inventory, tree.root,
1124
reverse=reverse)
1125
new_entries, remove_entries = \
1126
get_inventory_change(inventory, new_inventory, cset, reverse)
1127
tree.update_source_inventory(new_entries, remove_entries)
1128
1129
1130
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1131
new_entries = {}
1132
remove_entries = []
1133
r_inventory = invert_dict(inventory)
1134
r_new_inventory = invert_dict(new_inventory)
1135
for entry in cset.entries.itervalues():
1136
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)
1140
else:
1141
new_path = entry.get_new_path(inventory, cset)
1142
if new_path is not None:
1143
new_entries[new_path] = entry.id
1144
return new_entries, remove_entries
1145
1146
1147
def print_changeset(cset):
1148
"""Print all non-boring changeset entries
1149
1150
:param cset: The changeset to print
1151
:type cset: `Changeset`
1152
"""
1153
for entry in cset.entries.itervalues():
1154
if entry.is_boring():
1155
continue
1156
print entry.id
1157
print entry.summarize_name(cset)
1158
1159
class CompositionFailure(Exception):
1160
def __init__(self, old_entry, new_entry, problem):
1161
msg = "Unable to conpose entries.\n %s" % problem
1162
Exception.__init__(self, msg)
1163
1164
class IDMismatch(CompositionFailure):
1165
def __init__(self, old_entry, new_entry):
1166
problem = "Attempt to compose entries with different ids: %s and %s" %\
1167
(old_entry.id, new_entry.id)
1168
CompositionFailure.__init__(self, old_entry, new_entry, problem)
1169
1170
def compose_changesets(old_cset, new_cset):
1171
"""Combine two changesets into one. This works well for exact patching.
1172
Otherwise, not so well.
1173
1174
:param old_cset: The first changeset that would be applied
1175
:type old_cset: `Changeset`
1176
:param new_cset: The second changeset that would be applied
1177
:type new_cset: `Changeset`
1178
:return: A changeset that combines the changes in both changesets
1179
:rtype: `Changeset`
1180
"""
1181
composed = Changeset()
1182
for old_entry in old_cset.entries.itervalues():
1183
new_entry = new_cset.entries.get(old_entry.id)
1184
if new_entry is None:
1185
composed.add_entry(old_entry)
1186
else:
1187
composed_entry = compose_entries(old_entry, new_entry)
1188
if composed_entry.parent is not None or\
1189
composed_entry.new_parent is not None:
1190
composed.add_entry(composed_entry)
1191
for new_entry in new_cset.entries.itervalues():
1192
if not old_cset.entries.has_key(new_entry.id):
1193
composed.add_entry(new_entry)
1194
return composed
1195
1196
def compose_entries(old_entry, new_entry):
1197
"""Combine two entries into one.
1198
1199
:param old_entry: The first entry that would be applied
1200
:type old_entry: ChangesetEntry
1201
:param old_entry: The second entry that would be applied
1202
:type old_entry: ChangesetEntry
1203
:return: A changeset entry combining both entries
1204
:rtype: `ChangesetEntry`
1205
"""
1206
if old_entry.id != new_entry.id:
1207
raise IDMismatch(old_entry, new_entry)
1208
output = ChangesetEntry(old_entry.id, old_entry.parent, old_entry.path)
1209
1210
if (old_entry.parent != old_entry.new_parent or
1211
new_entry.parent != new_entry.new_parent):
1212
output.new_parent = new_entry.new_parent
1213
1214
if (old_entry.path != old_entry.new_path or
1215
new_entry.path != new_entry.new_path):
1216
output.new_path = new_entry.new_path
1217
1218
output.contents_change = compose_contents(old_entry, new_entry)
1219
output.metadata_change = compose_metadata(old_entry, new_entry)
1220
return output
1221
1222
def compose_contents(old_entry, new_entry):
1223
"""Combine the contents of two changeset entries. Entries are combined
1224
intelligently where possible, but the fallback behavior returns an
1225
ApplySequence.
1226
1227
:param old_entry: The first entry that would be applied
1228
:type old_entry: `ChangesetEntry`
1229
:param new_entry: The second entry that would be applied
1230
:type new_entry: `ChangesetEntry`
1231
:return: A combined contents change
1232
:rtype: anything supporting the apply(reverse=False) method
1233
"""
1234
old_contents = old_entry.contents_change
1235
new_contents = new_entry.contents_change
1236
if old_entry.contents_change is None:
1237
return new_entry.contents_change
1238
elif new_entry.contents_change is None:
1239
return old_entry.contents_change
1240
elif isinstance(old_contents, ReplaceContents) and \
1241
isinstance(new_contents, ReplaceContents):
1242
if old_contents.old_contents == new_contents.new_contents:
1243
return None
1244
else:
1245
return ReplaceContents(old_contents.old_contents,
1246
new_contents.new_contents)
1247
elif isinstance(old_contents, ApplySequence):
1248
output = ApplySequence(old_contents.changes)
1249
if isinstance(new_contents, ApplySequence):
1250
output.changes.extend(new_contents.changes)
1251
else:
1252
output.changes.append(new_contents)
1253
return output
1254
elif isinstance(new_contents, ApplySequence):
1255
output = ApplySequence((old_contents.changes,))
1256
output.extend(new_contents.changes)
1257
return output
1258
else:
1259
return ApplySequence((old_contents, new_contents))
1260
1261
def compose_metadata(old_entry, new_entry):
1262
old_meta = old_entry.metadata_change
1263
new_meta = new_entry.metadata_change
1264
if old_meta is None:
1265
return new_meta
1266
elif new_meta is None:
1267
return old_meta
1268
elif isinstance(old_meta, ChangeUnixPermissions) and \
1269
isinstance(new_meta, ChangeUnixPermissions):
1270
return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
1271
else:
1272
return ApplySequence(old_meta, new_meta)
1273
1274
1275
def changeset_is_null(changeset):
1276
for entry in changeset.entries.itervalues():
1277
if not entry.is_boring():
1278
return False
1279
return True
1280
1281
class UnsuppportedFiletype(Exception):
1282
def __init__(self, full_path, stat_result):
1283
msg = "The file \"%s\" is not a supported filetype." % full_path
1284
Exception.__init__(self, msg)
1285
self.full_path = full_path
1286
self.stat_result = stat_result
1287
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
1291
class ChangesetGenerator(object):
1292
def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
1293
object.__init__(self)
1294
self.tree_a = tree_a
1295
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)
1306
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
1314
1315
def __call__(self):
1316
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)
1321
if cs_entry is not None and not cs_entry.is_boring():
1322
cset.add_entry(cs_entry)
1323
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
for entry in list(cset.entries.itervalues()):
1332
if entry.parent != entry.new_parent:
1333
if not cset.entries.has_key(entry.parent) and\
1334
entry.parent != NULL_ID and entry.parent is not None:
1335
parent_entry = self.make_boring_entry(entry.parent)
1336
cset.add_entry(parent_entry)
1337
if not cset.entries.has_key(entry.new_parent) and\
1338
entry.new_parent != NULL_ID and \
1339
entry.new_parent is not None:
1340
parent_entry = self.make_boring_entry(entry.new_parent)
1341
cset.add_entry(parent_entry)
1342
return cset
1343
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)
1366
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)
1375
1376
cs_entry.new_path = new_path
1377
cs_entry.new_parent = new_parent
1378
return (cs_entry, full_path_a, full_path_b)
1379
1380
def is_interesting(self, entry_a, entry_b):
1381
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
1388
1389
def make_boring_entry(self, id):
1390
(cs_entry, full_path_a, full_path_b) = \
1391
self.make_basic_entry(id, only_interesting=False)
1392
if cs_entry.is_creation_or_deletion():
1393
return self.make_entry(id, only_interesting=False)
1394
else:
1395
return cs_entry
1396
1397
1398
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)
1401
1402
if cs_entry is None:
1403
return None
1404
1405
stat_a = self.lstat(full_path_a)
1406
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
1411
cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1412
cs_entry.contents_change = self.make_contents_change(full_path_a,
1413
stat_a,
1414
full_path_b,
1415
stat_b)
1416
return cs_entry
1417
1418
def make_mode_change(self, stat_a, stat_b):
1419
mode_a = None
1420
if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
1421
mode_a = stat_a.st_mode & 0777
1422
mode_b = None
1423
if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
1424
mode_b = stat_b.st_mode & 0777
1425
if mode_a == mode_b:
1426
return None
1427
return ChangeUnixPermissions(mode_a, mode_b)
1428
1429
def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
1430
if stat_a is None and stat_b is None:
1431
return None
1432
if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
1433
stat.S_ISDIR(stat_b.st_mode):
1434
return None
1435
if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
1436
stat.S_ISREG(stat_b.st_mode):
1437
if stat_a.st_ino == stat_b.st_ino and \
1438
stat_a.st_dev == stat_b.st_dev:
1439
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
1450
a_contents = self.get_contents(stat_a, full_path_a)
1451
b_contents = self.get_contents(stat_b, full_path_b)
1452
if a_contents == b_contents:
1453
return None
1454
return ReplaceContents(a_contents, b_contents)
1455
1456
def get_contents(self, stat_result, full_path):
1457
if stat_result is None:
1458
return None
1459
elif stat.S_ISREG(stat_result.st_mode):
1460
return FileCreate(file(full_path, "rb").read())
1461
elif stat.S_ISDIR(stat_result.st_mode):
1462
return dir_create
1463
elif stat.S_ISLNK(stat_result.st_mode):
1464
return SymlinkCreate(os.readlink(full_path))
1465
else:
1466
raise UnsupportedFiletype(full_path, stat_result)
1467
1468
def lstat(self, full_path):
1469
stat_result = None
1470
if full_path is not None:
1471
try:
1472
stat_result = os.lstat(full_path)
1473
except OSError, e:
1474
if e.errno != errno.ENOENT:
1475
raise
1476
return stat_result
1477
1478
1479
def full_path(entry, tree):
1480
return os.path.join(tree.root, entry.path)
1481
1482
def new_delete_entry(entry, tree, inventory, delete):
1483
if entry.path == "":
1484
parent = NULL_ID
1485
else:
1486
parent = inventory[dirname(entry.path)].id
1487
cs_entry = ChangesetEntry(parent, entry.path)
1488
if delete:
1489
cs_entry.new_path = None
1490
cs_entry.new_parent = None
1491
else:
1492
cs_entry.path = None
1493
cs_entry.parent = None
1494
full_path = full_path(entry, tree)
1495
status = os.lstat(full_path)
1496
if stat.S_ISDIR(file_stat.st_mode):
1497
action = dir_create
1498
1499
1500
1501
1502
1503
class Inventory:
1504
def __init__(self, inventory):
1505
self.inventory = inventory
1506
self.rinventory = None
1507
1508
def get_rinventory(self):
1509
if self.rinventory is None:
1510
self.rinventory = invert_dict(self.inventory)
1511
return self.rinventory
1512
1513
def get_path(self, id):
1514
return self.inventory.get(id)
1515
1516
def get_name(self, id):
1517
return os.path.basename(self.get_path(id))
1518
1519
def get_dir(self, id):
1520
path = self.get_path(id)
1521
if path == "":
1522
return None
1523
return os.path.dirname(path)
1524
1525
def get_parent(self, id):
1526
directory = self.get_dir(id)
1527
if directory == '.':
1528
directory = './.'
1529
if directory is None:
1530
return NULL_ID
1531
return self.get_rinventory().get(directory)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1