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