« 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:
- HACKING
- 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/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 tempfile import mkdtemp
29
from shutil import rmtree
30
from itertools import izip
31
32
from bzrlib.trace import mutter, warning
33
from bzrlib.osutils import rename, sha_file
34
import bzrlib
35
from bzrlib.errors import BzrCheckError
36
20
"""
21
Represent and apply a changeset
22
"""
37
23
__docformat__ = "restructuredtext"
38
24
39
25
NULL_ID = "!NULL"
48
34
newdict[value] = key
49
35
return newdict
50
36
51
52
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):
53
88
"""This is two-way change, suitable for file modification, creation,
54
89
deletion"""
55
def __init__(self, old_exec_flag, new_exec_flag):
56
self.old_exec_flag = old_exec_flag
57
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
58
93
59
94
def apply(self, filename, conflict_handler, reverse=False):
60
95
if not reverse:
61
from_exec_flag = self.old_exec_flag
62
to_exec_flag = self.new_exec_flag
96
from_mode = self.old_mode
97
to_mode = self.new_mode
63
98
else:
64
from_exec_flag = self.new_exec_flag
65
to_exec_flag = self.old_exec_flag
99
from_mode = self.new_mode
100
to_mode = self.old_mode
66
101
try:
67
current_exec_flag = bool(os.stat(filename).st_mode & 0111)
102
current_mode = os.stat(filename).st_mode &0777
68
103
except OSError, e:
69
104
if e.errno == errno.ENOENT:
70
if conflict_handler.missing_for_exec_flag(filename) == "skip":
105
if conflict_handler.missing_for_chmod(filename) == "skip":
71
106
return
72
107
else:
73
current_exec_flag = from_exec_flag
108
current_mode = from_mode
74
109
75
if from_exec_flag is not None and current_exec_flag != from_exec_flag:
76
if conflict_handler.wrong_old_exec_flag(filename,
77
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":
78
113
return
79
114
80
if to_exec_flag is not None:
81
current_mode = os.stat(filename).st_mode
82
if to_exec_flag:
83
umask = os.umask(0)
84
os.umask(umask)
85
to_mode = current_mode | (0100 & ~umask)
86
# Enable x-bit for others only if they can read it.
87
if current_mode & 0004:
88
to_mode |= 0001 & ~umask
89
if current_mode & 0040:
90
to_mode |= 0010 & ~umask
91
else:
92
to_mode = current_mode & ~0111
115
if to_mode is not None:
93
116
try:
94
117
os.chmod(filename, to_mode)
95
118
except IOError, e:
96
119
if e.errno == errno.ENOENT:
97
conflict_handler.missing_for_exec_flag(filename)
120
conflict_handler.missing_for_chmod(filename)
98
121
99
122
def __eq__(self, other):
100
return (isinstance(other, ChangeExecFlag) and
101
self.old_exec_flag == other.old_exec_flag and
102
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
103
131
104
132
def __ne__(self, other):
105
133
return not (self == other)
106
134
107
108
135
def dir_create(filename, conflict_handler, reverse):
109
136
"""Creates the directory, or deletes it if reverse is true. Intended to be
110
137
used with ReplaceContents.
130
157
try:
131
158
os.rmdir(filename)
132
159
except OSError, e:
133
if e.errno != errno.ENOTEMPTY:
160
if e.errno != 39:
134
161
raise
135
162
if conflict_handler.rmdir_non_empty(filename) == "skip":
136
163
return
137
164
os.rmdir(filename)
138
165
166
167
139
168
140
169
class SymlinkCreate(object):
141
170
"""Creates or deletes a symlink (for use with ReplaceContents)"""
147
176
"""
148
177
self.target = contents
149
178
150
def __repr__(self):
151
return "SymlinkCreate(%s)" % self.target
152
153
179
def __call__(self, filename, conflict_handler, reverse):
154
180
"""Creates or destroys the symlink.
155
181
237
263
238
264
239
265
240
class TreeFileCreate(object):
241
"""Create or delete a file (for use with ReplaceContents)"""
242
def __init__(self, tree, file_id):
243
"""Constructor
244
245
:param contents: The contents of the file to write
246
:type contents: str
247
"""
248
self.tree = tree
249
self.file_id = file_id
250
251
def __repr__(self):
252
return "TreeFileCreate(%s)" % self.file_id
253
254
def __eq__(self, other):
255
if not isinstance(other, TreeFileCreate):
256
return False
257
return self.tree.get_file_sha1(self.file_id) == \
258
other.tree.get_file_sha1(other.file_id)
259
260
def __ne__(self, other):
261
return not (self == other)
262
263
def write_file(self, filename):
264
outfile = file(filename, "wb")
265
for line in self.tree.get_file(self.file_id):
266
outfile.write(line)
267
268
def same_text(self, filename):
269
in_file = file(filename, "rb")
270
return sha_file(in_file) == self.tree.get_file_sha1(self.file_id)
271
272
def __call__(self, filename, conflict_handler, reverse):
273
"""Create or delete a file
274
275
:param filename: The name of the file to create
276
:type filename: str
277
:param reverse: Delete the file instead of creating it
278
:type reverse: bool
279
"""
280
if not reverse:
281
try:
282
self.write_file(filename)
283
except IOError, e:
284
if e.errno == errno.ENOENT:
285
if conflict_handler.missing_parent(filename)=="continue":
286
self.write_file(filename)
287
else:
288
raise
289
290
else:
291
try:
292
if not self.same_text(filename):
293
direction = conflict_handler.wrong_old_contents(filename,
294
self.tree.get_file(self.file_id).read())
295
if direction != "continue":
296
return
297
os.unlink(filename)
298
except IOError, e:
299
if e.errno != errno.ENOENT:
300
raise
301
if conflict_handler.missing_for_rm(filename, undo) == "skip":
302
return
303
304
305
306
266
def reversed(sequence):
307
267
max = len(sequence) - 1
308
268
for i in range(len(sequence)):
375
335
if mode is not None:
376
336
os.chmod(filename, mode)
377
337
378
def is_creation(self):
379
return self.new_contents is not None and self.old_contents is None
380
381
def is_deletion(self):
382
return self.old_contents is not None and self.new_contents is None
383
384
338
class ApplySequence(object):
385
339
def __init__(self, changes=None):
386
340
self.changes = []
412
366
413
367
414
368
class Diff3Merge(object):
415
history_based = False
416
def __init__(self, file_id, base, other):
417
self.file_id = file_id
418
self.base = base
419
self.other = other
420
421
def is_creation(self):
422
return False
423
424
def is_deletion(self):
425
return False
369
def __init__(self, base_file, other_file):
370
self.base_file = base_file
371
self.other_file = other_file
426
372
427
373
def __eq__(self, other):
428
374
if not isinstance(other, Diff3Merge):
429
375
return False
430
return (self.base == other.base and
431
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)
432
378
433
379
def __ne__(self, other):
434
380
return not (self == other)
435
381
436
def dump_file(self, temp_dir, name, tree):
437
out_path = os.path.join(temp_dir, name)
438
out_file = file(out_path, "wb")
439
in_file = tree.get_file(self.file_id)
440
for line in in_file:
441
out_file.write(line)
442
return out_path
443
444
382
def apply(self, filename, conflict_handler, reverse=False):
445
import bzrlib.patch
446
temp_dir = mkdtemp(prefix="bzr-")
447
try:
448
new_file = filename+".new"
449
base_file = self.dump_file(temp_dir, "base", self.base)
450
other_file = self.dump_file(temp_dir, "other", self.other)
451
if not reverse:
452
base = base_file
453
other = other_file
454
else:
455
base = other_file
456
other = base_file
457
status = bzrlib.patch.diff3(new_file, filename, base, other)
458
if status == 0:
459
os.chmod(new_file, os.stat(filename).st_mode)
460
rename(new_file, filename)
461
return
462
else:
463
assert(status == 1)
464
def get_lines(filename):
465
my_file = file(filename, "rb")
466
lines = my_file.readlines()
467
my_file.close()
468
return lines
469
base_lines = get_lines(base)
470
other_lines = get_lines(other)
471
conflict_handler.merge_conflict(new_file, filename, base_lines,
472
other_lines)
473
finally:
474
rmtree(temp_dir)
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)
475
398
476
399
477
400
def CreateDir():
510
433
"""
511
434
return ReplaceContents(FileCreate(contents), None)
512
435
513
def ReplaceFileContents(old_tree, new_tree, file_id):
436
def ReplaceFileContents(old_contents, new_contents):
514
437
"""Convenience fucntion to replace the contents of a file.
515
438
516
439
:param old_contents: The contents of the file to replace
520
443
:return: A ReplaceContents that will replace the contents of a file a file
521
444
:rtype: `ReplaceContents`
522
445
"""
523
return ReplaceContents(TreeFileCreate(old_tree, file_id),
524
TreeFileCreate(new_tree, file_id))
446
return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
525
447
526
448
def CreateSymlink(target):
527
449
"""Convenience fucntion to create a symlink.
633
555
if self.id == self.parent:
634
556
raise ParentIDIsSelf(self)
635
557
636
def __repr__(self):
558
def __str__(self):
637
559
return "ChangesetEntry(%s)" % self.id
638
560
639
__str__ = __repr__
640
641
561
def __get_dir(self):
642
562
if self.path is None:
643
563
return None
692
612
:param reverse: if true, the changeset is being applied in reverse
693
613
:rtype: bool
694
614
"""
695
return self.is_creation(not reverse)
615
return ((self.new_parent is None and not reverse) or
616
(self.parent is None and reverse))
696
617
697
618
def is_creation(self, reverse):
698
619
"""Return true if applying the entry would create a file/directory.
700
621
:param reverse: if true, the changeset is being applied in reverse
701
622
:rtype: bool
702
623
"""
703
if self.contents_change is None:
704
return False
705
if reverse:
706
return self.contents_change.is_deletion()
707
else:
708
return self.contents_change.is_creation()
624
return ((self.parent is None and not reverse) or
625
(self.new_parent is None and reverse))
709
626
710
627
def is_creation_or_deletion(self):
711
628
"""Return true if applying the entry would create or delete a
713
630
714
631
:rtype: bool
715
632
"""
716
return self.is_creation(False) or self.is_deletion(False)
633
return self.parent is None or self.new_parent is None
717
634
718
635
def get_cset_path(self, mod=False):
719
636
"""Determine the path of the entry according to the changeset.
739
656
return None
740
657
return self.path
741
658
742
def summarize_name(self, reverse=False):
659
def summarize_name(self, changeset, reverse=False):
743
660
"""Produce a one-line summary of the filename. Indicates renames as
744
661
old => new, indicates creation as None => new, indicates deletion as
745
662
old => None.
752
669
"""
753
670
orig_path = self.get_cset_path(False)
754
671
mod_path = self.get_cset_path(True)
755
if orig_path and orig_path.startswith('./'):
672
if orig_path is not None:
756
673
orig_path = orig_path[2:]
757
if mod_path and mod_path.startswith('./'):
674
if mod_path is not None:
758
675
mod_path = mod_path[2:]
759
676
if orig_path == mod_path:
760
677
return orig_path
776
693
:type reverse: bool
777
694
:rtype: str
778
695
"""
779
mutter("Finding new path for %s", self.summarize_name())
780
696
if reverse:
781
697
parent = self.parent
782
698
to_dir = self.dir
794
710
return None
795
711
796
712
if parent == NULL_ID or parent is None:
797
if to_name != u'.':
713
if to_name != '.':
798
714
raise SourceRootHasName(self, to_name)
799
715
else:
800
return u'.'
801
parent_entry = changeset.entries.get(parent)
802
if parent_entry is None:
716
return '.'
717
if from_dir == to_dir:
803
718
dir = os.path.dirname(id_map[self.id])
804
719
else:
805
mutter("path, new_path: %r %r", self.path, self.new_path)
720
parent_entry = changeset.entries[parent]
806
721
dir = parent_entry.get_new_path(id_map, changeset, reverse)
807
722
if from_name == to_name:
808
723
name = os.path.basename(id_map[self.id])
891
806
:rtype: (List, List)
892
807
"""
893
808
source_entries = [x for x in changeset.entries.itervalues()
894
if x.needs_rename() or x.is_creation_or_deletion()]
809
if x.needs_rename()]
895
810
# these are done from longest path to shortest, to avoid deleting a
896
811
# parent before its children are deleted/renamed
897
812
def longest_to_shortest(entry):
938
853
entry.apply(path, conflict_handler, reverse)
939
854
temp_name[entry.id] = None
940
855
941
elif entry.needs_rename():
942
if entry.is_creation(reverse):
943
continue
856
else:
944
857
to_name = os.path.join(temp_dir, str(i))
945
858
src_path = inventory.get(entry.id)
946
859
if src_path is not None:
947
860
src_path = os.path.join(dir, src_path)
948
861
try:
949
rename(src_path, to_name)
862
os.rename(src_path, to_name)
950
863
temp_name[entry.id] = to_name
951
864
except OSError, e:
952
865
if e.errno != errno.ENOENT:
953
866
raise
954
if conflict_handler.missing_for_rename(src_path, to_name) \
955
== "skip":
867
if conflict_handler.missing_for_rename(src_path) == "skip":
956
868
continue
957
869
958
870
return temp_name
979
891
continue
980
892
new_path = os.path.join(dir, new_tree_path)
981
893
old_path = changed_inventory.get(entry.id)
982
if bzrlib.osutils.lexists(new_path):
894
if os.path.exists(new_path):
983
895
if conflict_handler.target_exists(entry, new_path, old_path) == \
984
896
"skip":
985
897
continue
986
898
if entry.is_creation(reverse):
987
899
entry.apply(new_path, conflict_handler, reverse)
988
900
changed_inventory[entry.id] = new_tree_path
989
elif entry.needs_rename():
990
if entry.is_deletion(reverse):
991
continue
901
else:
992
902
if old_path is None:
993
903
continue
994
904
try:
995
mutter('rename %s to final name %s', old_path, new_path)
996
rename(old_path, new_path)
905
os.rename(old_path, new_path)
997
906
changed_inventory[entry.id] = new_tree_path
998
907
except OSError, e:
999
raise BzrCheckError('failed to rename %s to %s for changeset entry %s: %s'
1000
% (old_path, new_path, entry, e))
908
raise Exception ("%s is missing" % new_path)
1001
909
1002
910
class TargetExists(Exception):
1003
911
def __init__(self, entry, target):
1035
943
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
1036
944
self.this_path = this_path
1037
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)
960
1038
961
class WrongOldContents(Exception):
1039
962
def __init__(self, filename):
1040
963
msg = "Contents mismatch deleting %s" % filename
1041
964
self.filename = filename
1042
965
Exception.__init__(self, msg)
1043
966
1044
class WrongOldExecFlag(Exception):
1045
def __init__(self, filename, old_exec_flag, new_exec_flag):
1046
msg = "Executable flag missmatch on %s:\n" \
1047
"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)
1048
971
self.filename = filename
1049
972
Exception.__init__(self, msg)
1050
973
1068
991
Exception.__init__(self, msg)
1069
992
self.filename = filename
1070
993
1071
class MissingForSetExec(Exception):
994
class MissingPermsFile(Exception):
1072
995
def __init__(self, filename):
1073
996
msg = "Attempt to change permissions on %s, which does not exist" %\
1074
997
filename
1083
1006
1084
1007
1085
1008
class MissingForRename(Exception):
1086
def __init__(self, filename, to_path):
1087
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)
1088
1011
Exception.__init__(self, msg)
1089
1012
self.filename = filename
1090
1013
1093
1016
msg = "Conflicting contents for new file %s" % (filename)
1094
1017
Exception.__init__(self, msg)
1095
1018
1096
class WeaveMergeConflict(Exception):
1097
def __init__(self, filename):
1098
msg = "Conflicting contents for file %s" % (filename)
1099
Exception.__init__(self, msg)
1100
1101
class ThreewayContentsConflict(Exception):
1102
def __init__(self, filename):
1103
msg = "Conflicting contents for file %s" % (filename)
1104
Exception.__init__(self, msg)
1105
1106
1019
1107
1020
class MissingForMerge(Exception):
1108
1021
def __init__(self, filename):
1112
1025
1113
1026
1114
1027
class ExceptionConflictHandler(object):
1115
"""Default handler for merge exceptions.
1116
1117
This throws an error on any kind of conflict. Conflict handlers can
1118
descend from this class if they have a better way to handle some or
1119
all types of conflict.
1120
"""
1028
def __init__(self, dir):
1029
self.dir = dir
1030
1121
1031
def missing_parent(self, pathname):
1122
1032
parent = os.path.dirname(pathname)
1123
1033
raise Exception("Parent directory missing for %s" % pathname)
1134
1044
def rename_conflict(self, id, this_name, base_name, other_name):
1135
1045
raise RenameConflict(id, this_name, base_name, other_name)
1136
1046
1137
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)
1138
1051
raise MoveConflict(id, this_dir, base_dir, other_dir)
1139
1052
1140
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):
1141
1054
os.unlink(new_file)
1142
1055
raise MergeConflict(this_path)
1143
1056
1057
def permission_conflict(self, this_path, base_path, other_path):
1058
raise MergePermissionConflict(this_path, base_path, other_path)
1059
1144
1060
def wrong_old_contents(self, filename, expected_contents):
1145
1061
raise WrongOldContents(filename)
1146
1062
1147
1063
def rem_contents_conflict(self, filename, this_contents, base_contents):
1148
1064
raise RemoveContentsConflict(filename)
1149
1065
1150
def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
1151
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)
1152
1068
1153
1069
def rmdir_non_empty(self, filename):
1154
1070
raise DeletingNonEmptyDirectory(filename)
1159
1075
def patch_target_missing(self, filename, contents):
1160
1076
raise PatchTargetMissing(filename)
1161
1077
1162
def missing_for_exec_flag(self, filename):
1163
raise MissingForExecFlag(filename)
1078
def missing_for_chmod(self, filename):
1079
raise MissingPermsFile(filename)
1164
1080
1165
1081
def missing_for_rm(self, filename, change):
1166
1082
raise MissingForRm(filename)
1167
1083
1168
def missing_for_rename(self, filename, to_path):
1169
raise MissingForRename(filename, to_path)
1084
def missing_for_rename(self, filename):
1085
raise MissingForRename(filename)
1170
1086
1171
def missing_for_merge(self, file_id, other_path):
1172
raise MissingForMerge(other_path)
1087
def missing_for_merge(self, file_id, inventory):
1088
raise MissingForMerge(inventory.other.get_path(file_id))
1173
1089
1174
1090
def new_contents_conflict(self, filename, other_contents):
1175
1091
raise NewContentsConflict(filename)
1176
1092
1177
def weave_merge_conflict(self, filename, weave, other_i, out_file):
1178
raise WeaveMergeConflict(filename)
1179
1180
def threeway_contents_conflict(self, filename, this_contents,
1181
base_contents, other_contents):
1182
raise ThreewayContentsConflict(filename)
1183
1184
def finalize(self):
1093
def finalize():
1185
1094
pass
1186
1095
1187
1096
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1200
1109
:rtype: Dictionary
1201
1110
"""
1202
1111
if conflict_handler is None:
1203
conflict_handler = ExceptionConflictHandler()
1112
conflict_handler = ExceptionConflictHandler(dir)
1204
1113
temp_dir = os.path.join(dir, "bzr-tree-change")
1205
1114
try:
1206
1115
os.mkdir(temp_dir)
1217
1126
1218
1127
#apply changes that don't affect filenames
1219
1128
for entry in changeset.entries.itervalues():
1220
if not entry.is_creation_or_deletion() and not entry.is_boring():
1221
if entry.id not in inventory:
1222
warning("entry {%s} no longer present, can't be updated",
1223
entry.id)
1224
continue
1129
if not entry.is_creation_or_deletion():
1225
1130
path = os.path.join(dir, inventory[entry.id])
1226
1131
entry.apply(path, conflict_handler, reverse)
1227
1132
1246
1151
r_inventory = {}
1247
1152
for entry in tree.source_inventory().itervalues():
1248
1153
inventory[entry.id] = entry.path
1249
new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
1154
new_inventory = apply_changeset(cset, r_inventory, tree.root,
1250
1155
reverse=reverse)
1251
1156
new_entries, remove_entries = \
1252
1157
get_inventory_change(inventory, new_inventory, cset, reverse)
1387
1292
return new_meta
1388
1293
elif new_meta is None:
1389
1294
return old_meta
1390
elif (isinstance(old_meta, ChangeExecFlag) and
1391
isinstance(new_meta, ChangeExecFlag)):
1392
return ChangeExecFlag(old_meta.old_exec_flag, new_meta.new_exec_flag)
1295
elif isinstance(old_meta, ChangeUnixPermissions) and \
1296
isinstance(new_meta, ChangeUnixPermissions):
1297
return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
1393
1298
else:
1394
1299
return ApplySequence(old_meta, new_meta)
1395
1300
1400
1305
return False
1401
1306
return True
1402
1307
1403
class UnsupportedFiletype(Exception):
1404
def __init__(self, kind, full_path):
1405
msg = "The file \"%s\" is a %s, which is not a supported filetype." \
1406
% (full_path, kind)
1308
class UnsuppportedFiletype(Exception):
1309
def __init__(self, full_path, stat_result):
1310
msg = "The file \"%s\" is not a supported filetype." % full_path
1407
1311
Exception.__init__(self, msg)
1408
1312
self.full_path = full_path
1409
self.kind = kind
1410
1411
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1412
return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1413
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)()
1414
1317
1415
1318
class ChangesetGenerator(object):
1416
def __init__(self, tree_a, tree_b, interesting_ids=None):
1319
def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
1417
1320
object.__init__(self)
1418
1321
self.tree_a = tree_a
1419
1322
self.tree_b = tree_b
1420
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)
1421
1333
1422
def iter_both_tree_ids(self):
1423
for file_id in self.tree_a:
1424
yield file_id
1425
for file_id in self.tree_b:
1426
if file_id not in self.tree_a:
1427
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
1428
1341
1429
1342
def __call__(self):
1430
1343
cset = Changeset()
1431
for file_id in self.iter_both_tree_ids():
1432
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)
1433
1348
if cs_entry is not None and not cs_entry.is_boring():
1434
1349
cset.add_entry(cs_entry)
1435
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)
1436
1358
for entry in list(cset.entries.itervalues()):
1437
1359
if entry.parent != entry.new_parent:
1438
1360
if not cset.entries.has_key(entry.parent) and\
1446
1368
cset.add_entry(parent_entry)
1447
1369
return cset
1448
1370
1449
def iter_inventory(self, tree):
1450
for file_id in tree:
1451
yield self.get_entry(file_id, tree)
1452
1453
def get_entry(self, file_id, tree):
1454
if not tree.has_or_had_id(file_id):
1455
return None
1456
return tree.inventory[file_id]
1457
1458
def get_entry_parent(self, entry):
1459
if entry is None:
1460
return None
1461
return entry.parent_id
1462
1463
def get_path(self, file_id, tree):
1464
if not tree.has_or_had_id(file_id):
1465
return None
1466
path = tree.id2path(file_id)
1467
if path == '':
1468
return './.'
1469
else:
1470
return path
1471
1472
def make_basic_entry(self, file_id, only_interesting):
1473
entry_a = self.get_entry(file_id, self.tree_a)
1474
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)
1475
1393
if only_interesting and not self.is_interesting(entry_a, entry_b):
1476
return None
1477
parent = self.get_entry_parent(entry_a)
1478
path = self.get_path(file_id, self.tree_a)
1479
cs_entry = ChangesetEntry(file_id, parent, path)
1480
new_parent = self.get_entry_parent(entry_b)
1481
1482
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)
1483
1402
1484
1403
cs_entry.new_path = new_path
1485
1404
cs_entry.new_parent = new_parent
1486
return cs_entry
1405
return (cs_entry, full_path_a, full_path_b)
1487
1406
1488
1407
def is_interesting(self, entry_a, entry_b):
1489
if self._interesting_ids is None:
1490
return True
1491
1408
if entry_a is not None:
1492
file_id = entry_a.file_id
1493
elif entry_b is not None:
1494
file_id = entry_b.file_id
1495
else:
1496
return False
1497
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
1498
1415
1499
1416
def make_boring_entry(self, id):
1500
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)
1501
1419
if cs_entry.is_creation_or_deletion():
1502
1420
return self.make_entry(id, only_interesting=False)
1503
1421
else:
1505
1423
1506
1424
1507
1425
def make_entry(self, id, only_interesting=True):
1508
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)
1509
1428
1510
1429
if cs_entry is None:
1511
1430
return None
1512
1513
cs_entry.metadata_change = self.make_exec_flag_change(id)
1514
1515
if id in self.tree_a and id in self.tree_b:
1516
a_sha1 = self.tree_a.get_file_sha1(id)
1517
b_sha1 = self.tree_b.get_file_sha1(id)
1518
if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1519
return cs_entry
1520
1521
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)
1522
1443
return cs_entry
1523
1444
1524
def make_exec_flag_change(self, file_id):
1525
exec_flag_a = exec_flag_b = None
1526
if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
1527
exec_flag_a = self.tree_a.is_executable(file_id)
1528
1529
if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
1530
exec_flag_b = self.tree_b.is_executable(file_id)
1531
1532
if exec_flag_a == exec_flag_b:
1533
return None
1534
return ChangeExecFlag(exec_flag_a, exec_flag_b)
1535
1536
def make_contents_change(self, file_id):
1537
a_contents = get_contents(self.tree_a, file_id)
1538
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)
1539
1479
if a_contents == b_contents:
1540
1480
return None
1541
1481
return ReplaceContents(a_contents, b_contents)
1542
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)
1543
1494
1544
def get_contents(tree, file_id):
1545
"""Return the appropriate contents to create a copy of file_id from tree"""
1546
if file_id not in tree:
1547
return None
1548
kind = tree.kind(file_id)
1549
if kind == "file":
1550
return TreeFileCreate(tree, file_id)
1551
elif kind in ("directory", "root_directory"):
1552
return dir_create
1553
elif kind == "symlink":
1554
return SymlinkCreate(tree.get_symlink_target(file_id))
1555
else:
1556
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
1557
1504
1558
1505
1559
1506
def full_path(entry, tree):
1560
return os.path.join(tree.basedir, entry.path)
1507
return os.path.join(tree.root, entry.path)
1561
1508
1562
1509
def new_delete_entry(entry, tree, inventory, delete):
1563
1510
if entry.path == "":
1579
1526
1580
1527
1581
1528
1582
# XXX: Can't we unify this with the regular inventory object
1529
1583
1530
class Inventory(object):
1584
1531
def __init__(self, inventory):
1585
1532
self.inventory = inventory
1613
1560
return None
1614
1561
directory = self.get_dir(id)
1615
1562
if directory == '.':
1616
directory = u'./.'
1563
directory = './.'
1617
1564
if directory is None:
1618
1565
return NULL_ID
1619
1566
return self.get_rinventory().get(directory)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1