385
385
old_tree.unlock()
388
def _show_diff_trees(old_tree, new_tree, to_file,
389
specific_files, external_diff_options, path_encoding,
390
old_label='a/', new_label='b/', extra_trees=None):
392
# GNU Patch uses the epoch date to detect files that are being added
393
# or removed in a diff.
394
EPOCH_DATE = '1970-01-01 00:00:00 +0000'
396
# TODO: Generation of pseudo-diffs for added/deleted files could
397
# be usefully made into a much faster special case.
399
if external_diff_options:
400
assert isinstance(external_diff_options, basestring)
401
opts = external_diff_options.split()
402
def diff_file(olab, olines, nlab, nlines, to_file):
403
external_diff(olab, olines, nlab, nlines, to_file, opts)
405
diff_file = internal_diff
407
delta = new_tree.changes_from(old_tree,
408
specific_files=specific_files,
409
extra_trees=extra_trees, require_versioned=True)
412
for path, file_id, kind in delta.removed:
414
path_encoded = path.encode(path_encoding, "replace")
415
to_file.write("=== removed %s '%s'\n" % (kind, path_encoded))
416
old_name = '%s%s\t%s' % (old_label, path,
417
_patch_header_date(old_tree, file_id, path))
418
new_name = '%s%s\t%s' % (new_label, path, EPOCH_DATE)
419
old_tree.inventory[file_id].diff(diff_file, old_name, old_tree,
420
new_name, None, None, to_file)
421
for path, file_id, kind in delta.added:
423
path_encoded = path.encode(path_encoding, "replace")
424
to_file.write("=== added %s '%s'\n" % (kind, path_encoded))
425
old_name = '%s%s\t%s' % (old_label, path, EPOCH_DATE)
426
new_name = '%s%s\t%s' % (new_label, path,
427
_patch_header_date(new_tree, file_id, path))
428
new_tree.inventory[file_id].diff(diff_file, new_name, new_tree,
429
old_name, None, None, to_file,
431
for (old_path, new_path, file_id, kind,
432
text_modified, meta_modified) in delta.renamed:
434
prop_str = get_prop_change(meta_modified)
435
oldpath_encoded = old_path.encode(path_encoding, "replace")
436
newpath_encoded = new_path.encode(path_encoding, "replace")
437
to_file.write("=== renamed %s '%s' => '%s'%s\n" % (kind,
438
oldpath_encoded, newpath_encoded, prop_str))
439
old_name = '%s%s\t%s' % (old_label, old_path,
440
_patch_header_date(old_tree, file_id,
442
new_name = '%s%s\t%s' % (new_label, new_path,
443
_patch_header_date(new_tree, file_id,
445
_maybe_diff_file_or_symlink(old_name, old_tree, file_id,
447
text_modified, kind, to_file, diff_file)
448
for path, file_id, kind, text_modified, meta_modified in delta.modified:
450
prop_str = get_prop_change(meta_modified)
451
path_encoded = path.encode(path_encoding, "replace")
452
to_file.write("=== modified %s '%s'%s\n" % (kind,
453
path_encoded, prop_str))
454
# The file may be in a different location in the old tree (because
455
# the containing dir was renamed, but the file itself was not)
456
old_path = old_tree.id2path(file_id)
457
old_name = '%s%s\t%s' % (old_label, old_path,
458
_patch_header_date(old_tree, file_id, old_path))
459
new_name = '%s%s\t%s' % (new_label, path,
460
_patch_header_date(new_tree, file_id, path))
462
_maybe_diff_file_or_symlink(old_name, old_tree, file_id,
464
True, kind, to_file, diff_file)
469
388
def _patch_header_date(tree, file_id, path):
470
389
"""Returns a timestamp suitable for use in a patch header."""
471
390
mtime = tree.get_file_mtime(file_id, path)
504
def _maybe_diff_file_or_symlink(old_path, old_tree, file_id,
505
new_path, new_tree, text_modified,
506
kind, to_file, diff_file):
508
new_entry = new_tree.inventory[file_id]
509
old_tree.inventory[file_id].diff(diff_file,
423
class DiffPath(object):
424
"""Base type for command object that compare files"""
426
# The type or contents of the file were unsuitable for diffing
427
CANNOT_DIFF = 'CANNOT_DIFF'
428
# The file has changed in a semantic way
430
# The file content may have changed, but there is no semantic change
431
UNCHANGED = 'UNCHANGED'
433
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8'):
436
:param old_tree: The tree to show as the old tree in the comparison
437
:param new_tree: The tree to show as new in the comparison
438
:param to_file: The file to write comparison data to
439
:param path_encoding: The character encoding to write paths in
441
self.old_tree = old_tree
442
self.new_tree = new_tree
443
self.to_file = to_file
444
self.path_encoding = path_encoding
447
def from_diff_tree(klass, diff_tree):
448
return klass(diff_tree.old_tree, diff_tree.new_tree,
449
diff_tree.to_file, diff_tree.path_encoding)
452
def _diff_many(differs, file_id, old_path, new_path, old_kind, new_kind):
453
for file_differ in differs:
454
result = file_differ.diff(file_id, old_path, new_path, old_kind,
456
if result is not DiffPath.CANNOT_DIFF:
459
return DiffPath.CANNOT_DIFF
462
class DiffKindChange(object):
463
"""Special differ for file kind changes.
465
Represents kind change as deletion + creation. Uses the other differs
468
def __init__(self, differs):
469
self.differs = differs
472
def from_diff_tree(klass, diff_tree):
473
return klass(diff_tree.differs)
475
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
476
"""Perform comparison
478
:param file_id: The file_id of the file to compare
479
:param old_path: Path of the file in the old tree
480
:param new_path: Path of the file in the new tree
481
:param old_kind: Old file-kind of the file
482
:param new_kind: New file-kind of the file
484
if None in (old_kind, new_kind):
485
return DiffPath.CANNOT_DIFF
486
result = DiffPath._diff_many(self.differs, file_id, old_path,
487
new_path, old_kind, None)
488
if result is DiffPath.CANNOT_DIFF:
490
return DiffPath._diff_many(self.differs, file_id, old_path, new_path,
494
class DiffDirectory(DiffPath):
496
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
497
"""Perform comparison between two directories. (dummy)
500
if 'directory' not in (old_kind, new_kind):
501
return self.CANNOT_DIFF
502
if old_kind not in ('directory', None):
503
return self.CANNOT_DIFF
504
if new_kind not in ('directory', None):
505
return self.CANNOT_DIFF
509
class DiffSymlink(DiffPath):
511
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
512
"""Perform comparison between two symlinks
514
:param file_id: The file_id of the file to compare
515
:param old_path: Path of the file in the old tree
516
:param new_path: Path of the file in the new tree
517
:param old_kind: Old file-kind of the file
518
:param new_kind: New file-kind of the file
520
if 'symlink' not in (old_kind, new_kind):
521
return self.CANNOT_DIFF
522
if old_kind == 'symlink':
523
old_target = self.old_tree.get_symlink_target(file_id)
524
elif old_kind is None:
527
return self.CANNOT_DIFF
528
if new_kind == 'symlink':
529
new_target = self.new_tree.get_symlink_target(file_id)
530
elif new_kind is None:
533
return self.CANNOT_DIFF
534
return self.diff_symlink(old_target, new_target)
536
def diff_symlink(self, old_target, new_target):
537
if old_target is None:
538
self.to_file.write('=== target is %r\n' % new_target)
539
elif new_target is None:
540
self.to_file.write('=== target was %r\n' % old_target)
542
self.to_file.write('=== target changed %r => %r\n' %
543
(old_target, new_target))
547
class DiffText(DiffPath):
549
# GNU Patch uses the epoch date to detect files that are being added
550
# or removed in a diff.
551
EPOCH_DATE = '1970-01-01 00:00:00 +0000'
553
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
554
old_label='', new_label='', text_differ=internal_diff):
555
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
556
self.text_differ = text_differ
557
self.old_label = old_label
558
self.new_label = new_label
559
self.path_encoding = path_encoding
561
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
562
"""Compare two files in unified diff format
564
:param file_id: The file_id of the file to compare
565
:param old_path: Path of the file in the old tree
566
:param new_path: Path of the file in the new tree
567
:param old_kind: Old file-kind of the file
568
:param new_kind: New file-kind of the file
570
if 'file' not in (old_kind, new_kind):
571
return self.CANNOT_DIFF
572
from_file_id = to_file_id = file_id
573
if old_kind == 'file':
574
old_date = _patch_header_date(self.old_tree, file_id, old_path)
575
elif old_kind is None:
576
old_date = self.EPOCH_DATE
579
return self.CANNOT_DIFF
580
if new_kind == 'file':
581
new_date = _patch_header_date(self.new_tree, file_id, new_path)
582
elif new_kind is None:
583
new_date = self.EPOCH_DATE
586
return self.CANNOT_DIFF
587
from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
588
to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
589
return self.diff_text(from_file_id, to_file_id, from_label, to_label)
591
def diff_text(self, from_file_id, to_file_id, from_label, to_label):
592
"""Diff the content of given files in two trees
594
:param from_file_id: The id of the file in the from tree. If None,
595
the file is not present in the from tree.
596
:param to_file_id: The id of the file in the to tree. This may refer
597
to a different file from from_file_id. If None,
598
the file is not present in the to tree.
600
def _get_text(tree, file_id):
601
if file_id is not None:
602
return tree.get_file(file_id).readlines()
606
from_text = _get_text(self.old_tree, from_file_id)
607
to_text = _get_text(self.new_tree, to_file_id)
608
self.text_differ(from_label, from_text, to_label, to_text,
610
except errors.BinaryFile:
612
("Binary files %s and %s differ\n" %
613
(from_label, to_label)).encode(self.path_encoding))
617
class DiffTree(object):
618
"""Provides textual representations of the difference between two trees.
620
A DiffTree examines two trees and where a file-id has altered
621
between them, generates a textual representation of the difference.
622
DiffTree uses a sequence of DiffPath objects which are each
623
given the opportunity to handle a given altered fileid. The list
624
of DiffPath objects can be extended globally by appending to
625
DiffTree.diff_factories, or for a specific diff operation by
626
supplying the extra_factories option to the appropriate method.
629
# list of factories that can provide instances of DiffPath objects
630
# may be extended by plugins.
631
diff_factories = [DiffSymlink.from_diff_tree,
632
DiffDirectory.from_diff_tree]
634
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
635
diff_text=None, extra_factories=None):
638
:param old_tree: Tree to show as old in the comparison
639
:param new_tree: Tree to show as new in the comparison
640
:param to_file: File to write comparision to
641
:param path_encoding: Character encoding to write paths in
642
:param diff_text: DiffPath-type object to use as a last resort for
644
:param extra_factories: Factories of DiffPaths to try before any other
646
if diff_text is None:
647
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
648
'', '', internal_diff)
649
self.old_tree = old_tree
650
self.new_tree = new_tree
651
self.to_file = to_file
652
self.path_encoding = path_encoding
654
if extra_factories is not None:
655
self.differs.extend(f(self) for f in extra_factories)
656
self.differs.extend(f(self) for f in self.diff_factories)
657
self.differs.extend([diff_text, DiffKindChange.from_diff_tree(self)])
660
def from_trees_options(klass, old_tree, new_tree, to_file,
661
path_encoding, external_diff_options, old_label,
663
"""Factory for producing a DiffTree.
665
Designed to accept options used by show_diff_trees.
666
:param old_tree: The tree to show as old in the comparison
667
:param new_tree: The tree to show as new in the comparison
668
:param to_file: File to write comparisons to
669
:param path_encoding: Character encoding to use for writing paths
670
:param external_diff_options: If supplied, use the installed diff
671
binary to perform file comparison, using supplied options.
672
:param old_label: Prefix to use for old file labels
673
:param new_label: Prefix to use for new file labels
675
if external_diff_options:
676
assert isinstance(external_diff_options, basestring)
677
opts = external_diff_options.split()
678
def diff_file(olab, olines, nlab, nlines, to_file):
679
external_diff(olab, olines, nlab, nlines, to_file, opts)
681
diff_file = internal_diff
682
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
683
old_label, new_label, diff_file)
684
return klass(old_tree, new_tree, to_file, path_encoding, diff_text)
686
def show_diff(self, specific_files, extra_trees=None):
687
"""Write tree diff to self.to_file
689
:param sepecific_files: the specific files to compare (recursive)
690
:param extra_trees: extra trees to use for mapping paths to file_ids
692
# TODO: Generation of pseudo-diffs for added/deleted files could
693
# be usefully made into a much faster special case.
695
delta = self.new_tree.changes_from(self.old_tree,
696
specific_files=specific_files,
697
extra_trees=extra_trees, require_versioned=True)
700
for path, file_id, kind in delta.removed:
702
path_encoded = path.encode(self.path_encoding, "replace")
703
self.to_file.write("=== removed %s '%s'\n" % (kind, path_encoded))
704
self.diff(file_id, path, path)
706
for path, file_id, kind in delta.added:
708
path_encoded = path.encode(self.path_encoding, "replace")
709
self.to_file.write("=== added %s '%s'\n" % (kind, path_encoded))
710
self.diff(file_id, path, path)
711
for (old_path, new_path, file_id, kind,
712
text_modified, meta_modified) in delta.renamed:
714
prop_str = get_prop_change(meta_modified)
715
oldpath_encoded = old_path.encode(self.path_encoding, "replace")
716
newpath_encoded = new_path.encode(self.path_encoding, "replace")
717
self.to_file.write("=== renamed %s '%s' => '%s'%s\n" % (kind,
718
oldpath_encoded, newpath_encoded, prop_str))
720
self.diff(file_id, old_path, new_path)
721
for path, file_id, kind, text_modified, meta_modified in\
724
prop_str = get_prop_change(meta_modified)
725
path_encoded = path.encode(self.path_encoding, "replace")
726
self.to_file.write("=== modified %s '%s'%s\n" % (kind,
727
path_encoded, prop_str))
728
# The file may be in a different location in the old tree (because
729
# the containing dir was renamed, but the file itself was not)
731
old_path = self.old_tree.id2path(file_id)
732
self.diff(file_id, old_path, path)
735
def diff(self, file_id, old_path, new_path):
736
"""Perform a diff of a single file
738
:param file_id: file-id of the file
739
:param old_path: The path of the file in the old tree
740
:param new_path: The path of the file in the new tree
743
old_kind = self.old_tree.kind(file_id)
744
except errors.NoSuchId:
747
new_kind = self.new_tree.kind(file_id)
748
except errors.NoSuchId:
751
result = DiffPath._diff_many(self.differs, file_id, old_path,
752
new_path, old_kind, new_kind)
753
if result is DiffPath.CANNOT_DIFF:
754
error_path = new_path
755
if error_path is None:
756
error_path = old_path
757
raise errors.NoDiffFound(error_path)
added
removed
bzrlib/diff.py
