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