« back to all changes in this revision
Viewing changes to bzrlib/changeset.py
- browse files at revision 294
- compare with another revision
- download diff
- download tarball
- view history from revision 294
- Committer: Martin Pool
- Date: 2005-04-28 07:24:55 UTC
- Revision ID: mbp@sourcefrog.net-20050428072453-7b99afa993a1e549
todo
- files added:
- bzrlib/tests.py
- files removed:
- bzr-man.py
- contrib
- contrib/bash
- contrib/zsh
- patches
- files modified:
- .bzrignore
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(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
84
class ChangeUnixPermissions(object):
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(object):
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(object):
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(object):
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(object):
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(object):
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(object):
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(object):
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 finalize():
1070
pass
1071
1072
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1073
reverse=False):
1074
"""Apply a changeset to a directory.
1075
1076
:param changeset: The changes to perform
1077
:type changeset: `Changeset`
1078
:param inventory: The mapping of id to filename for the directory
1079
:type inventory: Dictionary
1080
:param dir: The path of the directory to apply the changes to
1081
:type dir: str
1082
:param reverse: If true, apply the changes in reverse
1083
:type reverse: bool
1084
:return: The mapping of the changed entries
1085
:rtype: Dictionary
1086
"""
1087
if conflict_handler is None:
1088
conflict_handler = ExceptionConflictHandler(dir)
1089
temp_dir = dir+"/temp"
1090
os.mkdir(temp_dir)
1091
1092
#apply changes that don't affect filenames
1093
for entry in changeset.entries.itervalues():
1094
if not entry.is_creation_or_deletion():
1095
path = os.path.join(dir, inventory[entry.id])
1096
entry.apply(path, conflict_handler, reverse)
1097
1098
# Apply renames in stages, to minimize conflicts:
1099
# Only files whose name or parent change are interesting, because their
1100
# target name may exist in the source tree. If a directory's name changes,
1101
# that doesn't make its children interesting.
1102
(source_entries, target_entries) = get_rename_entries(changeset, inventory,
1103
reverse)
1104
1105
temp_name = rename_to_temp_delete(source_entries, inventory, dir,
1106
conflict_handler, reverse)
1107
1108
rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
1109
conflict_handler, reverse)
1110
os.rmdir(temp_dir)
1111
r_inventory = invert_dict(inventory)
1112
new_entries, removed_entries = get_inventory_change(inventory,
1113
r_inventory, changeset, reverse)
1114
new_inventory = {}
1115
for path, file_id in new_entries.iteritems():
1116
new_inventory[file_id] = path
1117
for file_id in removed_entries:
1118
new_inventory[file_id] = None
1119
return new_inventory
1120
1121
1122
def apply_changeset_tree(cset, tree, reverse=False):
1123
r_inventory = {}
1124
for entry in tree.source_inventory().itervalues():
1125
inventory[entry.id] = entry.path
1126
new_inventory = apply_changeset(cset, r_inventory, tree.root,
1127
reverse=reverse)
1128
new_entries, remove_entries = \
1129
get_inventory_change(inventory, new_inventory, cset, reverse)
1130
tree.update_source_inventory(new_entries, remove_entries)
1131
1132
1133
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1134
new_entries = {}
1135
remove_entries = []
1136
r_inventory = invert_dict(inventory)
1137
r_new_inventory = invert_dict(new_inventory)
1138
for entry in cset.entries.itervalues():
1139
if entry.needs_rename():
1140
old_path = r_inventory.get(entry.id)
1141
if old_path is not None:
1142
remove_entries.append(old_path)
1143
else:
1144
new_path = entry.get_new_path(inventory, cset)
1145
if new_path is not None:
1146
new_entries[new_path] = entry.id
1147
return new_entries, remove_entries
1148
1149
1150
def print_changeset(cset):
1151
"""Print all non-boring changeset entries
1152
1153
:param cset: The changeset to print
1154
:type cset: `Changeset`
1155
"""
1156
for entry in cset.entries.itervalues():
1157
if entry.is_boring():
1158
continue
1159
print entry.id
1160
print entry.summarize_name(cset)
1161
1162
class CompositionFailure(Exception):
1163
def __init__(self, old_entry, new_entry, problem):
1164
msg = "Unable to conpose entries.\n %s" % problem
1165
Exception.__init__(self, msg)
1166
1167
class IDMismatch(CompositionFailure):
1168
def __init__(self, old_entry, new_entry):
1169
problem = "Attempt to compose entries with different ids: %s and %s" %\
1170
(old_entry.id, new_entry.id)
1171
CompositionFailure.__init__(self, old_entry, new_entry, problem)
1172
1173
def compose_changesets(old_cset, new_cset):
1174
"""Combine two changesets into one. This works well for exact patching.
1175
Otherwise, not so well.
1176
1177
:param old_cset: The first changeset that would be applied
1178
:type old_cset: `Changeset`
1179
:param new_cset: The second changeset that would be applied
1180
:type new_cset: `Changeset`
1181
:return: A changeset that combines the changes in both changesets
1182
:rtype: `Changeset`
1183
"""
1184
composed = Changeset()
1185
for old_entry in old_cset.entries.itervalues():
1186
new_entry = new_cset.entries.get(old_entry.id)
1187
if new_entry is None:
1188
composed.add_entry(old_entry)
1189
else:
1190
composed_entry = compose_entries(old_entry, new_entry)
1191
if composed_entry.parent is not None or\
1192
composed_entry.new_parent is not None:
1193
composed.add_entry(composed_entry)
1194
for new_entry in new_cset.entries.itervalues():
1195
if not old_cset.entries.has_key(new_entry.id):
1196
composed.add_entry(new_entry)
1197
return composed
1198
1199
def compose_entries(old_entry, new_entry):
1200
"""Combine two entries into one.
1201
1202
:param old_entry: The first entry that would be applied
1203
:type old_entry: ChangesetEntry
1204
:param old_entry: The second entry that would be applied
1205
:type old_entry: ChangesetEntry
1206
:return: A changeset entry combining both entries
1207
:rtype: `ChangesetEntry`
1208
"""
1209
if old_entry.id != new_entry.id:
1210
raise IDMismatch(old_entry, new_entry)
1211
output = ChangesetEntry(old_entry.id, old_entry.parent, old_entry.path)
1212
1213
if (old_entry.parent != old_entry.new_parent or
1214
new_entry.parent != new_entry.new_parent):
1215
output.new_parent = new_entry.new_parent
1216
1217
if (old_entry.path != old_entry.new_path or
1218
new_entry.path != new_entry.new_path):
1219
output.new_path = new_entry.new_path
1220
1221
output.contents_change = compose_contents(old_entry, new_entry)
1222
output.metadata_change = compose_metadata(old_entry, new_entry)
1223
return output
1224
1225
def compose_contents(old_entry, new_entry):
1226
"""Combine the contents of two changeset entries. Entries are combined
1227
intelligently where possible, but the fallback behavior returns an
1228
ApplySequence.
1229
1230
:param old_entry: The first entry that would be applied
1231
:type old_entry: `ChangesetEntry`
1232
:param new_entry: The second entry that would be applied
1233
:type new_entry: `ChangesetEntry`
1234
:return: A combined contents change
1235
:rtype: anything supporting the apply(reverse=False) method
1236
"""
1237
old_contents = old_entry.contents_change
1238
new_contents = new_entry.contents_change
1239
if old_entry.contents_change is None:
1240
return new_entry.contents_change
1241
elif new_entry.contents_change is None:
1242
return old_entry.contents_change
1243
elif isinstance(old_contents, ReplaceContents) and \
1244
isinstance(new_contents, ReplaceContents):
1245
if old_contents.old_contents == new_contents.new_contents:
1246
return None
1247
else:
1248
return ReplaceContents(old_contents.old_contents,
1249
new_contents.new_contents)
1250
elif isinstance(old_contents, ApplySequence):
1251
output = ApplySequence(old_contents.changes)
1252
if isinstance(new_contents, ApplySequence):
1253
output.changes.extend(new_contents.changes)
1254
else:
1255
output.changes.append(new_contents)
1256
return output
1257
elif isinstance(new_contents, ApplySequence):
1258
output = ApplySequence((old_contents.changes,))
1259
output.extend(new_contents.changes)
1260
return output
1261
else:
1262
return ApplySequence((old_contents, new_contents))
1263
1264
def compose_metadata(old_entry, new_entry):
1265
old_meta = old_entry.metadata_change
1266
new_meta = new_entry.metadata_change
1267
if old_meta is None:
1268
return new_meta
1269
elif new_meta is None:
1270
return old_meta
1271
elif isinstance(old_meta, ChangeUnixPermissions) and \
1272
isinstance(new_meta, ChangeUnixPermissions):
1273
return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
1274
else:
1275
return ApplySequence(old_meta, new_meta)
1276
1277
1278
def changeset_is_null(changeset):
1279
for entry in changeset.entries.itervalues():
1280
if not entry.is_boring():
1281
return False
1282
return True
1283
1284
class UnsuppportedFiletype(Exception):
1285
def __init__(self, full_path, stat_result):
1286
msg = "The file \"%s\" is not a supported filetype." % full_path
1287
Exception.__init__(self, msg)
1288
self.full_path = full_path
1289
self.stat_result = stat_result
1290
1291
def generate_changeset(tree_a, tree_b, inventory_a=None, inventory_b=None):
1292
return ChangesetGenerator(tree_a, tree_b, inventory_a, inventory_b)()
1293
1294
class ChangesetGenerator(object):
1295
def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
1296
object.__init__(self)
1297
self.tree_a = tree_a
1298
self.tree_b = tree_b
1299
if inventory_a is not None:
1300
self.inventory_a = inventory_a
1301
else:
1302
self.inventory_a = tree_a.inventory()
1303
if inventory_b is not None:
1304
self.inventory_b = inventory_b
1305
else:
1306
self.inventory_b = tree_b.inventory()
1307
self.r_inventory_a = self.reverse_inventory(self.inventory_a)
1308
self.r_inventory_b = self.reverse_inventory(self.inventory_b)
1309
1310
def reverse_inventory(self, inventory):
1311
r_inventory = {}
1312
for entry in inventory.itervalues():
1313
if entry.id is None:
1314
continue
1315
r_inventory[entry.id] = entry
1316
return r_inventory
1317
1318
def __call__(self):
1319
cset = Changeset()
1320
for entry in self.inventory_a.itervalues():
1321
if entry.id is None:
1322
continue
1323
cs_entry = self.make_entry(entry.id)
1324
if cs_entry is not None and not cs_entry.is_boring():
1325
cset.add_entry(cs_entry)
1326
1327
for entry in self.inventory_b.itervalues():
1328
if entry.id is None:
1329
continue
1330
if not self.r_inventory_a.has_key(entry.id):
1331
cs_entry = self.make_entry(entry.id)
1332
if cs_entry is not None and not cs_entry.is_boring():
1333
cset.add_entry(cs_entry)
1334
for entry in list(cset.entries.itervalues()):
1335
if entry.parent != entry.new_parent:
1336
if not cset.entries.has_key(entry.parent) and\
1337
entry.parent != NULL_ID and entry.parent is not None:
1338
parent_entry = self.make_boring_entry(entry.parent)
1339
cset.add_entry(parent_entry)
1340
if not cset.entries.has_key(entry.new_parent) and\
1341
entry.new_parent != NULL_ID and \
1342
entry.new_parent is not None:
1343
parent_entry = self.make_boring_entry(entry.new_parent)
1344
cset.add_entry(parent_entry)
1345
return cset
1346
1347
def get_entry_parent(self, entry, inventory):
1348
if entry is None:
1349
return None
1350
if entry.path == "./.":
1351
return NULL_ID
1352
dirname = os.path.dirname(entry.path)
1353
if dirname == ".":
1354
dirname = "./."
1355
parent = inventory[dirname]
1356
return parent.id
1357
1358
def get_paths(self, entry, tree):
1359
if entry is None:
1360
return (None, None)
1361
full_path = tree.readonly_path(entry.id)
1362
if entry.path == ".":
1363
return ("", full_path)
1364
return (entry.path, full_path)
1365
1366
def make_basic_entry(self, id, only_interesting):
1367
entry_a = self.r_inventory_a.get(id)
1368
entry_b = self.r_inventory_b.get(id)
1369
if only_interesting and not self.is_interesting(entry_a, entry_b):
1370
return (None, None, None)
1371
parent = self.get_entry_parent(entry_a, self.inventory_a)
1372
(path, full_path_a) = self.get_paths(entry_a, self.tree_a)
1373
cs_entry = ChangesetEntry(id, parent, path)
1374
new_parent = self.get_entry_parent(entry_b, self.inventory_b)
1375
1376
1377
(new_path, full_path_b) = self.get_paths(entry_b, self.tree_b)
1378
1379
cs_entry.new_path = new_path
1380
cs_entry.new_parent = new_parent
1381
return (cs_entry, full_path_a, full_path_b)
1382
1383
def is_interesting(self, entry_a, entry_b):
1384
if entry_a is not None:
1385
if entry_a.interesting:
1386
return True
1387
if entry_b is not None:
1388
if entry_b.interesting:
1389
return True
1390
return False
1391
1392
def make_boring_entry(self, id):
1393
(cs_entry, full_path_a, full_path_b) = \
1394
self.make_basic_entry(id, only_interesting=False)
1395
if cs_entry.is_creation_or_deletion():
1396
return self.make_entry(id, only_interesting=False)
1397
else:
1398
return cs_entry
1399
1400
1401
def make_entry(self, id, only_interesting=True):
1402
(cs_entry, full_path_a, full_path_b) = \
1403
self.make_basic_entry(id, only_interesting)
1404
1405
if cs_entry is None:
1406
return None
1407
1408
stat_a = self.lstat(full_path_a)
1409
stat_b = self.lstat(full_path_b)
1410
if stat_b is None:
1411
cs_entry.new_parent = None
1412
cs_entry.new_path = None
1413
1414
cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1415
cs_entry.contents_change = self.make_contents_change(full_path_a,
1416
stat_a,
1417
full_path_b,
1418
stat_b)
1419
return cs_entry
1420
1421
def make_mode_change(self, stat_a, stat_b):
1422
mode_a = None
1423
if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
1424
mode_a = stat_a.st_mode & 0777
1425
mode_b = None
1426
if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
1427
mode_b = stat_b.st_mode & 0777
1428
if mode_a == mode_b:
1429
return None
1430
return ChangeUnixPermissions(mode_a, mode_b)
1431
1432
def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
1433
if stat_a is None and stat_b is None:
1434
return None
1435
if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
1436
stat.S_ISDIR(stat_b.st_mode):
1437
return None
1438
if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
1439
stat.S_ISREG(stat_b.st_mode):
1440
if stat_a.st_ino == stat_b.st_ino and \
1441
stat_a.st_dev == stat_b.st_dev:
1442
return None
1443
if file(full_path_a, "rb").read() == \
1444
file(full_path_b, "rb").read():
1445
return None
1446
1447
patch_contents = patch.diff(full_path_a,
1448
file(full_path_b, "rb").read())
1449
if patch_contents is None:
1450
return None
1451
return PatchApply(patch_contents)
1452
1453
a_contents = self.get_contents(stat_a, full_path_a)
1454
b_contents = self.get_contents(stat_b, full_path_b)
1455
if a_contents == b_contents:
1456
return None
1457
return ReplaceContents(a_contents, b_contents)
1458
1459
def get_contents(self, stat_result, full_path):
1460
if stat_result is None:
1461
return None
1462
elif stat.S_ISREG(stat_result.st_mode):
1463
return FileCreate(file(full_path, "rb").read())
1464
elif stat.S_ISDIR(stat_result.st_mode):
1465
return dir_create
1466
elif stat.S_ISLNK(stat_result.st_mode):
1467
return SymlinkCreate(os.readlink(full_path))
1468
else:
1469
raise UnsupportedFiletype(full_path, stat_result)
1470
1471
def lstat(self, full_path):
1472
stat_result = None
1473
if full_path is not None:
1474
try:
1475
stat_result = os.lstat(full_path)
1476
except OSError, e:
1477
if e.errno != errno.ENOENT:
1478
raise
1479
return stat_result
1480
1481
1482
def full_path(entry, tree):
1483
return os.path.join(tree.root, entry.path)
1484
1485
def new_delete_entry(entry, tree, inventory, delete):
1486
if entry.path == "":
1487
parent = NULL_ID
1488
else:
1489
parent = inventory[dirname(entry.path)].id
1490
cs_entry = ChangesetEntry(parent, entry.path)
1491
if delete:
1492
cs_entry.new_path = None
1493
cs_entry.new_parent = None
1494
else:
1495
cs_entry.path = None
1496
cs_entry.parent = None
1497
full_path = full_path(entry, tree)
1498
status = os.lstat(full_path)
1499
if stat.S_ISDIR(file_stat.st_mode):
1500
action = dir_create
1501
1502
1503
1504
1505
1506
class Inventory(object):
1507
def __init__(self, inventory):
1508
self.inventory = inventory
1509
self.rinventory = None
1510
1511
def get_rinventory(self):
1512
if self.rinventory is None:
1513
self.rinventory = invert_dict(self.inventory)
1514
return self.rinventory
1515
1516
def get_path(self, id):
1517
return self.inventory.get(id)
1518
1519
def get_name(self, id):
1520
return os.path.basename(self.get_path(id))
1521
1522
def get_dir(self, id):
1523
path = self.get_path(id)
1524
if path == "":
1525
return None
1526
return os.path.dirname(path)
1527
1528
def get_parent(self, id):
1529
directory = self.get_dir(id)
1530
if directory == '.':
1531
directory = './.'
1532
if directory is None:
1533
return NULL_ID
1534
return self.get_rinventory().get(directory)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1