mirror of
https://github.com/dgtlmoon/changedetection.io.git
synced 2026-04-30 14:50:39 +00:00
dgtlmoon
324 lines
15 KiB
Python
324 lines
15 KiB
Python
import difflib
|
|
from typing import List, Iterator, Union
|
|
|
|
# Remember! gmail, outlook etc dont support <style> must be inline.
|
|
# Gmail: strips <ins> and <del> tags entirely.
|
|
REMOVED_STYLE = "background-color: #fadad7; color: #b30000;"
|
|
ADDED_STYLE = "background-color: #eaf2c2; color: #406619;"
|
|
|
|
def render_inline_word_diff(before_line: str, after_line: str, html_colour: bool = False, ignore_junk: bool = False) -> str:
|
|
"""
|
|
Render word-level differences between two lines inline.
|
|
|
|
Args:
|
|
before_line: Original line text
|
|
after_line: Modified line text
|
|
html_colour: Use HTML background colors for differences
|
|
ignore_junk: Ignore whitespace-only changes
|
|
|
|
Returns:
|
|
str: Single line with inline word-level highlighting
|
|
"""
|
|
# Use difflib for word-level comparison (splitting on whitespace)
|
|
import re
|
|
|
|
# Tokenize into words and whitespace
|
|
def tokenize(text):
|
|
# Split on word boundaries, keeping delimiters
|
|
return re.findall(r'\S+|\s+', text)
|
|
|
|
before_tokens = tokenize(before_line)
|
|
after_tokens = tokenize(after_line)
|
|
|
|
# Use SequenceMatcher to find word-level differences
|
|
# If ignore_junk is True, treat whitespace tokens as junk
|
|
isjunk = (lambda x: x.strip() == '') if ignore_junk else None
|
|
matcher = difflib.SequenceMatcher(isjunk, before_tokens, after_tokens)
|
|
|
|
if html_colour:
|
|
result = []
|
|
for tag, i1, i2, j1, j2 in matcher.get_opcodes():
|
|
if tag == 'equal':
|
|
result.append(''.join(before_tokens[i1:i2]))
|
|
elif tag == 'delete':
|
|
deleted = ''.join(before_tokens[i1:i2])
|
|
# If only whitespace and ignore_junk is enabled, preserve whitespace without marking
|
|
if ignore_junk and deleted.strip() == '':
|
|
result.append(deleted)
|
|
continue
|
|
result.append(f'<span style="{REMOVED_STYLE}" title="Removed">{deleted}</span>')
|
|
elif tag == 'insert':
|
|
inserted = ''.join(after_tokens[j1:j2])
|
|
# If only whitespace and ignore_junk is enabled, preserve whitespace without marking
|
|
if ignore_junk and inserted.strip() == '':
|
|
result.append(inserted)
|
|
continue
|
|
result.append(f'<span style="{ADDED_STYLE}" title="Added">{inserted}</span>')
|
|
elif tag == 'replace':
|
|
deleted = ''.join(before_tokens[i1:i2])
|
|
inserted = ''.join(after_tokens[j1:j2])
|
|
# If both are only whitespace and ignore_junk is enabled, use the after version
|
|
if ignore_junk and deleted.strip() == '' and inserted.strip() == '':
|
|
result.append(inserted)
|
|
continue
|
|
# When ignore_junk is enabled, filter out whitespace-only tokens from replace operations
|
|
if ignore_junk:
|
|
deleted_parts = []
|
|
inserted_parts = []
|
|
for token in before_tokens[i1:i2]:
|
|
if token.strip() != '':
|
|
deleted_parts.append(token)
|
|
for token in after_tokens[j1:j2]:
|
|
if token.strip() != '':
|
|
inserted_parts.append(token)
|
|
# Add a single space between words (normalized whitespace)
|
|
if deleted_parts or inserted_parts:
|
|
result.append(' ')
|
|
if deleted_parts:
|
|
result.append(f'<span style="{REMOVED_STYLE}" title="Removed">{"".join(deleted_parts)}</span>')
|
|
if inserted_parts:
|
|
result.append(f'<span style="{ADDED_STYLE}" title="Added">{"".join(inserted_parts)}</span>')
|
|
else:
|
|
result.append(f'<span style="{REMOVED_STYLE}" title="Removed">{deleted}</span>')
|
|
result.append(f'<span style="{ADDED_STYLE}" title="Added">{inserted}</span>')
|
|
return ''.join(result)
|
|
else:
|
|
# Plain text format with markers
|
|
result = []
|
|
for tag, i1, i2, j1, j2 in matcher.get_opcodes():
|
|
if tag == 'equal':
|
|
result.append(''.join(before_tokens[i1:i2]))
|
|
elif tag == 'delete':
|
|
deleted = ''.join(before_tokens[i1:i2])
|
|
# If only whitespace and ignore_junk is enabled, preserve whitespace without marking
|
|
if ignore_junk and deleted.strip() == '':
|
|
result.append(deleted)
|
|
continue
|
|
result.append(f'[-{deleted}-]')
|
|
elif tag == 'insert':
|
|
inserted = ''.join(after_tokens[j1:j2])
|
|
# If only whitespace and ignore_junk is enabled, preserve whitespace without marking
|
|
if ignore_junk and inserted.strip() == '':
|
|
result.append(inserted)
|
|
continue
|
|
result.append(f'[+{inserted}+]')
|
|
elif tag == 'replace':
|
|
deleted = ''.join(before_tokens[i1:i2])
|
|
inserted = ''.join(after_tokens[j1:j2])
|
|
# If both are only whitespace and ignore_junk is enabled, use the after version
|
|
if ignore_junk and deleted.strip() == '' and inserted.strip() == '':
|
|
result.append(inserted)
|
|
continue
|
|
# When ignore_junk is enabled, filter out whitespace-only tokens from replace operations
|
|
if ignore_junk:
|
|
deleted_parts = []
|
|
inserted_parts = []
|
|
for token in before_tokens[i1:i2]:
|
|
if token.strip() != '':
|
|
deleted_parts.append(token)
|
|
for token in after_tokens[j1:j2]:
|
|
if token.strip() != '':
|
|
inserted_parts.append(token)
|
|
# Add a single space between words (normalized whitespace)
|
|
if deleted_parts or inserted_parts:
|
|
result.append(' ')
|
|
if deleted_parts:
|
|
result.append(f'[-{"".join(deleted_parts)}-]')
|
|
if inserted_parts:
|
|
result.append(f'[+{"".join(inserted_parts)}+]')
|
|
else:
|
|
result.append(f'[-{deleted}-]')
|
|
result.append(f'[+{inserted}+]')
|
|
return ''.join(result)
|
|
|
|
def same_slicer(lst: List[str], start: int, end: int) -> List[str]:
|
|
"""Return a slice of the list, or a single element if start == end."""
|
|
return lst[start:end] if start != end else [lst[start]]
|
|
|
|
def customSequenceMatcher(
|
|
before: List[str],
|
|
after: List[str],
|
|
include_equal: bool = False,
|
|
include_removed: bool = True,
|
|
include_added: bool = True,
|
|
include_replaced: bool = True,
|
|
include_change_type_prefix: bool = True,
|
|
html_colour: bool = False,
|
|
word_diff: bool = False,
|
|
context_lines: int = 0,
|
|
case_insensitive: bool = False,
|
|
ignore_junk: bool = False
|
|
) -> Iterator[List[str]]:
|
|
"""
|
|
Compare two sequences and yield differences based on specified parameters.
|
|
|
|
Args:
|
|
before (List[str]): Original sequence
|
|
after (List[str]): Modified sequence
|
|
include_equal (bool): Include unchanged parts
|
|
include_removed (bool): Include removed parts
|
|
include_added (bool): Include added parts
|
|
include_replaced (bool): Include replaced parts
|
|
include_change_type_prefix (bool): Add prefixes to indicate change types
|
|
html_colour (bool): Use HTML background colors for differences
|
|
word_diff (bool): Use word-level diffing for replaced lines
|
|
context_lines (int): Number of unchanged lines to show around changes (like grep -C)
|
|
case_insensitive (bool): Perform case-insensitive comparison
|
|
ignore_junk (bool): Ignore whitespace-only changes
|
|
|
|
Yields:
|
|
List[str]: Differences between sequences
|
|
"""
|
|
# Prepare sequences for comparison (lowercase if case-insensitive, normalize whitespace if ignore_junk)
|
|
import re
|
|
def prepare_line(line):
|
|
if case_insensitive:
|
|
line = line.lower()
|
|
if ignore_junk:
|
|
# Normalize whitespace: replace multiple spaces/tabs with single space
|
|
line = re.sub(r'\s+', ' ', line)
|
|
return line
|
|
|
|
compare_before = [prepare_line(line) for line in before]
|
|
compare_after = [prepare_line(line) for line in after]
|
|
|
|
cruncher = difflib.SequenceMatcher(isjunk=lambda x: x in " \t", a=compare_before, b=compare_after)
|
|
|
|
# When context_lines is set and include_equal is False, we need to track which equal lines to include
|
|
if context_lines > 0 and not include_equal:
|
|
opcodes = list(cruncher.get_opcodes())
|
|
# Mark equal ranges that should be included based on context
|
|
included_equal_ranges = set()
|
|
|
|
for i, (tag, alo, ahi, blo, bhi) in enumerate(opcodes):
|
|
if tag != 'equal':
|
|
# Include context lines before this change
|
|
for j in range(max(0, i - 1), i):
|
|
if opcodes[j][0] == 'equal':
|
|
prev_alo, prev_ahi = opcodes[j][1], opcodes[j][2]
|
|
# Include last N lines of the previous equal block
|
|
context_start = max(prev_alo, prev_ahi - context_lines)
|
|
for line_num in range(context_start, prev_ahi):
|
|
included_equal_ranges.add(line_num)
|
|
|
|
# Include context lines after this change
|
|
for j in range(i + 1, min(len(opcodes), i + 2)):
|
|
if opcodes[j][0] == 'equal':
|
|
next_alo, next_ahi = opcodes[j][1], opcodes[j][2]
|
|
# Include first N lines of the next equal block
|
|
context_end = min(next_ahi, next_alo + context_lines)
|
|
for line_num in range(next_alo, context_end):
|
|
included_equal_ranges.add(line_num)
|
|
|
|
# Remember! gmail, outlook etc dont support <style> must be inline.
|
|
# Gmail: strips <ins> and <del> tags entirely.
|
|
for tag, alo, ahi, blo, bhi in cruncher.get_opcodes():
|
|
if tag == 'equal':
|
|
if include_equal:
|
|
yield before[alo:ahi]
|
|
elif context_lines > 0:
|
|
# Only include equal lines that are in the context range
|
|
context_lines_to_include = [before[i] for i in range(alo, ahi) if i in included_equal_ranges]
|
|
if context_lines_to_include:
|
|
yield context_lines_to_include
|
|
elif include_removed and tag == 'delete':
|
|
if html_colour:
|
|
yield [f'<span style="{REMOVED_STYLE}" title="Removed">{line}</span>' for line in same_slicer(before, alo, ahi)]
|
|
else:
|
|
yield [f"(removed) {line}" for line in same_slicer(before, alo, ahi)] if include_change_type_prefix else same_slicer(before, alo, ahi)
|
|
elif include_replaced and tag == 'replace':
|
|
before_lines = same_slicer(before, alo, ahi)
|
|
after_lines = same_slicer(after, blo, bhi)
|
|
|
|
# Use word-level diff for single line replacements when enabled
|
|
if word_diff and len(before_lines) == 1 and len(after_lines) == 1:
|
|
inline_diff = render_inline_word_diff(before_lines[0], after_lines[0], html_colour, ignore_junk)
|
|
# Check if there are any actual changes (not just whitespace when ignore_junk is enabled)
|
|
if ignore_junk:
|
|
# Check if the output contains any change markers
|
|
if html_colour:
|
|
has_changes = '<span style=' in inline_diff
|
|
else:
|
|
has_changes = '[-' in inline_diff or '[+' in inline_diff
|
|
if not has_changes:
|
|
# No real changes, skip this line
|
|
continue
|
|
yield [inline_diff]
|
|
else:
|
|
# Fall back to line-level diff for multi-line changes or when word_diff disabled
|
|
if html_colour:
|
|
yield [f'<span style="{REMOVED_STYLE}" title="Removed">{line}</span>' for line in before_lines] + \
|
|
[f'<span style="{ADDED_STYLE}" title="Replaced">{line}</span>' for line in after_lines]
|
|
else:
|
|
yield [f"(changed) {line}" for line in before_lines] + \
|
|
[f"(into) {line}" for line in after_lines] if include_change_type_prefix else before_lines + after_lines
|
|
elif include_added and tag == 'insert':
|
|
if html_colour:
|
|
yield [f'<span style="{ADDED_STYLE}" title="Inserted">{line}</span>' for line in same_slicer(after, blo, bhi)]
|
|
else:
|
|
yield [f"(added) {line}" for line in same_slicer(after, blo, bhi)] if include_change_type_prefix else same_slicer(after, blo, bhi)
|
|
|
|
def render_diff(
|
|
previous_version_file_contents: str,
|
|
newest_version_file_contents: str,
|
|
include_equal: bool = False,
|
|
include_removed: bool = True,
|
|
include_added: bool = True,
|
|
include_replaced: bool = True,
|
|
line_feed_sep: str = "\n",
|
|
include_change_type_prefix: bool = True,
|
|
patch_format: bool = False,
|
|
html_colour: bool = False,
|
|
word_diff: bool = True,
|
|
context_lines: int = 0,
|
|
case_insensitive: bool = False,
|
|
ignore_junk: bool = False
|
|
) -> str:
|
|
"""
|
|
Render the difference between two file contents.
|
|
|
|
Args:
|
|
previous_version_file_contents (str): Original file contents
|
|
newest_version_file_contents (str): Modified file contents
|
|
include_equal (bool): Include unchanged parts
|
|
include_removed (bool): Include removed parts
|
|
include_added (bool): Include added parts
|
|
include_replaced (bool): Include replaced parts
|
|
line_feed_sep (str): Separator for lines in output
|
|
include_change_type_prefix (bool): Add prefixes to indicate change types
|
|
patch_format (bool): Use patch format for output
|
|
html_colour (bool): Use HTML background colors for differences
|
|
word_diff (bool): Use word-level diffing for replaced lines
|
|
context_lines (int): Number of unchanged lines to show around changes (like grep -C)
|
|
case_insensitive (bool): Perform case-insensitive comparison, By default the test_json_diff/process.py is case sensitive, so this follows same logic
|
|
ignore_junk (bool): Ignore whitespace-only changes
|
|
|
|
Returns:
|
|
str: Rendered difference
|
|
"""
|
|
newest_lines = [line.rstrip() for line in newest_version_file_contents.splitlines()]
|
|
previous_lines = [line.rstrip() for line in previous_version_file_contents.splitlines()] if previous_version_file_contents else []
|
|
|
|
if patch_format:
|
|
patch = difflib.unified_diff(previous_lines, newest_lines)
|
|
return line_feed_sep.join(patch)
|
|
|
|
rendered_diff = customSequenceMatcher(
|
|
before=previous_lines,
|
|
after=newest_lines,
|
|
include_equal=include_equal,
|
|
include_removed=include_removed,
|
|
include_added=include_added,
|
|
include_replaced=include_replaced,
|
|
include_change_type_prefix=include_change_type_prefix,
|
|
html_colour=html_colour,
|
|
word_diff=word_diff,
|
|
context_lines=context_lines,
|
|
case_insensitive=case_insensitive,
|
|
ignore_junk=ignore_junk
|
|
)
|
|
|
|
def flatten(lst: List[Union[str, List[str]]]) -> str:
|
|
return line_feed_sep.join(flatten(x) if isinstance(x, list) else x for x in lst)
|
|
|
|
return flatten(rendered_diff) |