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