385
387
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
390
def _patch_header_date(tree, file_id, path):
470
391
"""Returns a timestamp suitable for use in a patch header."""
471
392
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,
425
class DiffPath(object):
426
"""Base type for command object that compare files"""
428
# The type or contents of the file were unsuitable for diffing
429
CANNOT_DIFF = 'CANNOT_DIFF'
430
# The file has changed in a semantic way
432
# The file content may have changed, but there is no semantic change
433
UNCHANGED = 'UNCHANGED'
435
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8'):
438
:param old_tree: The tree to show as the old tree in the comparison
439
:param new_tree: The tree to show as new in the comparison
440
:param to_file: The file to write comparison data to
441
:param path_encoding: The character encoding to write paths in
443
self.old_tree = old_tree
444
self.new_tree = new_tree
445
self.to_file = to_file
446
self.path_encoding = path_encoding
449
def from_diff_tree(klass, diff_tree):
450
return klass(diff_tree.old_tree, diff_tree.new_tree,
451
diff_tree.to_file, diff_tree.path_encoding)
454
def _diff_many(differs, file_id, old_path, new_path, old_kind, new_kind):
455
for file_differ in differs:
456
result = file_differ.diff(file_id, old_path, new_path, old_kind,
458
if result is not DiffPath.CANNOT_DIFF:
461
return DiffPath.CANNOT_DIFF
464
class DiffKindChange(object):
465
"""Special differ for file kind changes.
467
Represents kind change as deletion + creation. Uses the other differs
470
def __init__(self, differs):
471
self.differs = differs
474
def from_diff_tree(klass, diff_tree):
475
return klass(diff_tree.differs)
477
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
478
"""Perform comparison
480
:param file_id: The file_id of the file to compare
481
:param old_path: Path of the file in the old tree
482
:param new_path: Path of the file in the new tree
483
:param old_kind: Old file-kind of the file
484
:param new_kind: New file-kind of the file
486
if None in (old_kind, new_kind):
487
return DiffPath.CANNOT_DIFF
488
result = DiffPath._diff_many(self.differs, file_id, old_path,
489
new_path, old_kind, None)
490
if result is DiffPath.CANNOT_DIFF:
492
return DiffPath._diff_many(self.differs, file_id, old_path, new_path,
496
class DiffDirectory(DiffPath):
498
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
499
"""Perform comparison between two directories. (dummy)
502
if 'directory' not in (old_kind, new_kind):
503
return self.CANNOT_DIFF
504
if old_kind not in ('directory', None):
505
return self.CANNOT_DIFF
506
if new_kind not in ('directory', None):
507
return self.CANNOT_DIFF
511
class DiffSymlink(DiffPath):
513
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
514
"""Perform comparison between two symlinks
516
:param file_id: The file_id of the file to compare
517
:param old_path: Path of the file in the old tree
518
:param new_path: Path of the file in the new tree
519
:param old_kind: Old file-kind of the file
520
:param new_kind: New file-kind of the file
522
if 'symlink' not in (old_kind, new_kind):
523
return self.CANNOT_DIFF
524
if old_kind == 'symlink':
525
old_target = self.old_tree.get_symlink_target(file_id)
526
elif old_kind is None:
529
return self.CANNOT_DIFF
530
if new_kind == 'symlink':
531
new_target = self.new_tree.get_symlink_target(file_id)
532
elif new_kind is None:
535
return self.CANNOT_DIFF
536
return self.diff_symlink(old_target, new_target)
538
def diff_symlink(self, old_target, new_target):
539
if old_target is None:
540
self.to_file.write('=== target is %r\n' % new_target)
541
elif new_target is None:
542
self.to_file.write('=== target was %r\n' % old_target)
544
self.to_file.write('=== target changed %r => %r\n' %
545
(old_target, new_target))
549
class DiffText(DiffPath):
551
# GNU Patch uses the epoch date to detect files that are being added
552
# or removed in a diff.
553
EPOCH_DATE = '1970-01-01 00:00:00 +0000'
555
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
556
old_label='', new_label='', text_differ=internal_diff):
557
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
558
self.text_differ = text_differ
559
self.old_label = old_label
560
self.new_label = new_label
561
self.path_encoding = path_encoding
563
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
564
"""Compare two files in unified diff format
566
:param file_id: The file_id of the file to compare
567
:param old_path: Path of the file in the old tree
568
:param new_path: Path of the file in the new tree
569
:param old_kind: Old file-kind of the file
570
:param new_kind: New file-kind of the file
572
if 'file' not in (old_kind, new_kind):
573
return self.CANNOT_DIFF
574
from_file_id = to_file_id = file_id
575
if old_kind == 'file':
576
old_date = _patch_header_date(self.old_tree, file_id, old_path)
577
elif old_kind is None:
578
old_date = self.EPOCH_DATE
581
return self.CANNOT_DIFF
582
if new_kind == 'file':
583
new_date = _patch_header_date(self.new_tree, file_id, new_path)
584
elif new_kind is None:
585
new_date = self.EPOCH_DATE
588
return self.CANNOT_DIFF
589
from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
590
to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
591
return self.diff_text(from_file_id, to_file_id, from_label, to_label)
593
def diff_text(self, from_file_id, to_file_id, from_label, to_label):
594
"""Diff the content of given files in two trees
596
:param from_file_id: The id of the file in the from tree. If None,
597
the file is not present in the from tree.
598
:param to_file_id: The id of the file in the to tree. This may refer
599
to a different file from from_file_id. If None,
600
the file is not present in the to tree.
602
def _get_text(tree, file_id):
603
if file_id is not None:
604
return tree.get_file(file_id).readlines()
608
from_text = _get_text(self.old_tree, from_file_id)
609
to_text = _get_text(self.new_tree, to_file_id)
610
self.text_differ(from_label, from_text, to_label, to_text,
612
except errors.BinaryFile:
614
("Binary files %s and %s differ\n" %
615
(from_label, to_label)).encode(self.path_encoding))
619
class DiffTree(object):
620
"""Provides textual representations of the difference between two trees.
622
A DiffTree examines two trees and where a file-id has altered
623
between them, generates a textual representation of the difference.
624
DiffTree uses a sequence of DiffPath objects which are each
625
given the opportunity to handle a given altered fileid. The list
626
of DiffPath objects can be extended globally by appending to
627
DiffTree.diff_factories, or for a specific diff operation by
628
supplying the extra_factories option to the appropriate method.
631
# list of factories that can provide instances of DiffPath objects
632
# may be extended by plugins.
633
diff_factories = [DiffSymlink.from_diff_tree,
634
DiffDirectory.from_diff_tree]
636
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
637
diff_text=None, extra_factories=None):
640
:param old_tree: Tree to show as old in the comparison
641
:param new_tree: Tree to show as new in the comparison
642
:param to_file: File to write comparision to
643
:param path_encoding: Character encoding to write paths in
644
:param diff_text: DiffPath-type object to use as a last resort for
646
:param extra_factories: Factories of DiffPaths to try before any other
648
if diff_text is None:
649
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
650
'', '', internal_diff)
651
self.old_tree = old_tree
652
self.new_tree = new_tree
653
self.to_file = to_file
654
self.path_encoding = path_encoding
656
if extra_factories is not None:
657
self.differs.extend(f(self) for f in extra_factories)
658
self.differs.extend(f(self) for f in self.diff_factories)
659
self.differs.extend([diff_text, DiffKindChange.from_diff_tree(self)])
662
def from_trees_options(klass, old_tree, new_tree, to_file,
663
path_encoding, external_diff_options, old_label,
665
"""Factory for producing a DiffTree.
667
Designed to accept options used by show_diff_trees.
668
:param old_tree: The tree to show as old in the comparison
669
:param new_tree: The tree to show as new in the comparison
670
:param to_file: File to write comparisons to
671
:param path_encoding: Character encoding to use for writing paths
672
:param external_diff_options: If supplied, use the installed diff
673
binary to perform file comparison, using supplied options.
674
:param old_label: Prefix to use for old file labels
675
:param new_label: Prefix to use for new file labels
677
if external_diff_options:
678
assert isinstance(external_diff_options, basestring)
679
opts = external_diff_options.split()
680
def diff_file(olab, olines, nlab, nlines, to_file):
681
external_diff(olab, olines, nlab, nlines, to_file, opts)
683
diff_file = internal_diff
684
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
685
old_label, new_label, diff_file)
686
return klass(old_tree, new_tree, to_file, path_encoding, diff_text)
688
def show_diff(self, specific_files, extra_trees=None):
689
"""Write tree diff to self.to_file
691
:param sepecific_files: the specific files to compare (recursive)
692
:param extra_trees: extra trees to use for mapping paths to file_ids
694
# TODO: Generation of pseudo-diffs for added/deleted files could
695
# be usefully made into a much faster special case.
697
delta = self.new_tree.changes_from(self.old_tree,
698
specific_files=specific_files,
699
extra_trees=extra_trees, require_versioned=True)
702
for path, file_id, kind in delta.removed:
704
path_encoded = path.encode(self.path_encoding, "replace")
705
self.to_file.write("=== removed %s '%s'\n" % (kind, path_encoded))
706
self.diff(file_id, path, path)
708
for path, file_id, kind in delta.added:
710
path_encoded = path.encode(self.path_encoding, "replace")
711
self.to_file.write("=== added %s '%s'\n" % (kind, path_encoded))
712
self.diff(file_id, path, path)
713
for (old_path, new_path, file_id, kind,
714
text_modified, meta_modified) in delta.renamed:
716
prop_str = get_prop_change(meta_modified)
717
oldpath_encoded = old_path.encode(self.path_encoding, "replace")
718
newpath_encoded = new_path.encode(self.path_encoding, "replace")
719
self.to_file.write("=== renamed %s '%s' => '%s'%s\n" % (kind,
720
oldpath_encoded, newpath_encoded, prop_str))
722
self.diff(file_id, old_path, new_path)
723
for path, file_id, kind, text_modified, meta_modified in\
726
prop_str = get_prop_change(meta_modified)
727
path_encoded = path.encode(self.path_encoding, "replace")
728
self.to_file.write("=== modified %s '%s'%s\n" % (kind,
729
path_encoded, prop_str))
730
# The file may be in a different location in the old tree (because
731
# the containing dir was renamed, but the file itself was not)
733
old_path = self.old_tree.id2path(file_id)
734
self.diff(file_id, old_path, path)
737
def diff(self, file_id, old_path, new_path):
738
"""Perform a diff of a single file
740
:param file_id: file-id of the file
741
:param old_path: The path of the file in the old tree
742
:param new_path: The path of the file in the new tree
745
old_kind = self.old_tree.kind(file_id)
746
except (errors.NoSuchId, errors.NoSuchFile):
749
new_kind = self.new_tree.kind(file_id)
750
except (errors.NoSuchId, errors.NoSuchFile):
753
result = DiffPath._diff_many(self.differs, file_id, old_path,
754
new_path, old_kind, new_kind)
755
if result is DiffPath.CANNOT_DIFF:
756
error_path = new_path
757
if error_path is None:
758
error_path = old_path
759
raise errors.NoDiffFound(error_path)
added
removed
bzrlib/diff.py
