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