Category: Expert Guide
Is there a way to customize the appearance of text-diff results?
# The Ultimate Authoritative Guide to Customizing text-diff Results: A Cybersecurity Lead's Perspective
## Executive Summary
In the dynamic landscape of cybersecurity, accurate and efficient text comparison is paramount. Whether analyzing security logs, reviewing code for vulnerabilities, or auditing configuration files, the ability to quickly identify and understand differences is crucial. The `text-diff` tool, a powerful and versatile library, offers robust text comparison capabilities. However, its default output, while functional, may not always align with the specific needs of security professionals, hindering rapid comprehension or integration into existing workflows. This definitive guide, authored from the perspective of a seasoned Cybersecurity Lead, delves into the intricate question: **"Is there a way to customize the appearance of text-diff results?"**
The answer is a resounding **yes**. This guide provides an in-depth exploration of how to tailor `text-diff`'s output to meet exacting cybersecurity requirements. We will dissect the underlying mechanisms that govern its rendering, explore advanced customization techniques, and demonstrate their practical application through a series of real-world cybersecurity scenarios. By understanding and leveraging these customization options, security teams can significantly enhance their efficiency, improve clarity in incident response, and strengthen their overall security posture. This guide aims to be the definitive resource, equipping cybersecurity professionals with the knowledge to transform raw text-diff outputs into actionable intelligence, perfectly integrated into their operational frameworks.
## Deep Technical Analysis: Unpacking the Customization Potential of text-diff
The `text-diff` library, at its core, is designed to compute differences between two sequences of lines. Its fundamental output typically highlights added, deleted, and unchanged lines. However, the perceived "appearance" of these results is not a static, unchangeable entity. Instead, it's a product of how the library's output is interpreted and rendered, often through subsequent processing or direct manipulation of its output format.
### Understanding the `text-diff` Output Structure
Before diving into customization, it's essential to understand what `text-diff` provides. The library typically returns a structured representation of the differences, often as a list of operations or a sequence of lines with specific markers. Common representations include:
* **Operation-based Diff:** This format describes the changes as a sequence of insert, delete, and equal operations. For example:
[
{'operation': 'equal', 'text': 'line 1'},
{'operation': 'delete', 'text': 'line 2 removed'},
{'operation': 'insert', 'text': 'line 3 added'}
]
* **Line-based Diff with Markers:** This format presents the combined lines, with specific markers indicating additions and deletions. For example, using a common diff utility convention:
- line 2 removed
+ line 3 added
line 1
The default presentation of these structures varies depending on the specific implementation or wrapper used. However, the underlying data is rich with information that can be manipulated.
### The Pillars of Customization
Customizing `text-diff` results hinges on two primary approaches:
1. **Leveraging Built-in Formatting Options (if available):** Some `text-diff` implementations or accompanying utilities might offer basic formatting flags. These are often the simplest to use but also the most limited.
2. **Post-processing and Re-rendering:** This is where the true power of customization lies. By taking the raw output of `text-diff` and processing it further, we can achieve virtually any desired appearance. This involves:
* **Parsing the Diff Output:** Understanding the structure of the diff (as outlined above) is key.
* **Applying Styles:** Introducing visual cues like colors, bolding, italics, or background highlights.
* **Structuring the Output:** Organizing the diff into more readable formats like HTML tables, side-by-side comparisons, or annotated lists.
* **Integrating with Other Tools:** Feeding the customized output into reporting systems, dashboards, or security information and event management (SIEM) platforms.
### Implementing Customization: Technical Deep Dive
Let's explore the technical mechanisms for achieving customization. We will focus on Python, a prevalent language in cybersecurity and a common environment for `text-diff` usage.
#### Scenario 1: Basic Styling with Python
Many `text-diff` libraries, or common ways of using them, generate output that can be easily parsed. Consider a Python library that provides a list of dictionaries representing the diff.
python
# Assuming a hypothetical text_diff library for demonstration
# In reality, you'd use a library like 'diff_match_patch' or 'difflib'
# and process its output.
def get_text_diff_operations(text1, text2):
"""
Simulates getting diff operations from a text-diff library.
In a real scenario, this would involve calling a library function.
"""
# This is a simplified representation for demonstration.
# Real libraries will have more sophisticated algorithms.
lines1 = text1.splitlines()
lines2 = text2.splitlines()
# A very basic diff logic for illustration
diff = []
i, j = 0, 0
while i < len(lines1) and j < len(lines2):
if lines1[i] == lines2[j]:
diff.append({'operation': 'equal', 'text': lines1[i]})
i += 1
j += 1
elif i + 1 < len(lines1) and lines1[i+1] == lines2[j]:
diff.append({'operation': 'delete', 'text': lines1[i]})
i += 1
elif j + 1 < len(lines2) and lines1[i] == lines2[j+1]:
diff.append({'operation': 'insert', 'text': lines2[j]})
j += 1
else:
# Handle more complex cases (substitutions, etc.)
# For simplicity, we'll treat them as delete/insert
diff.append({'operation': 'delete', 'text': lines1[i]})
i += 1
diff.append({'operation': 'insert', 'text': lines2[j]})
j += 1
while i < len(lines1):
diff.append({'operation': 'delete', 'text': lines1[i]})
i += 1
while j < len(lines2):
diff.append({'operation': 'insert', 'text': lines2[j]})
j += 1
return diff
def customize_diff_output_html(diff_operations):
"""
Customizes the text-diff output into an HTML list with styling.
"""
html_output = "
"
return html_output
# Example Usage:
text1 = """
This is the original configuration.
It contains several important settings.
# This is a comment line.
Enable_Logging = True
Debug_Mode = False
API_Key = abcdef123456
"""
text2 = """
This is the modified configuration.
It contains several important settings.
# This is an updated comment.
Enable_Logging = True
Debug_Mode = True
API_Key = XXXXXXXX
Max_Connections = 100
"""
# Get the raw diff operations
diff_ops = get_text_diff_operations(text1, text2)
# Customize into HTML list
customized_html_list = customize_diff_output_html(diff_ops)
print("--- Customized HTML List Output ---")
print(customized_html_list)
print("\n")
# Customize into HTML table
customized_html_table = customize_diff_output_table(diff_ops)
print("--- Customized HTML Table Output ---")
print(customized_html_table)
print("\n")
**Explanation:**
* **`get_text_diff_operations`:** This function simulates the output of a `text-diff` library. In a real application, you would replace this with calls to libraries like `difflib` (Python's built-in) or external libraries that might offer more advanced diffing algorithms. The output is a list of dictionaries, each specifying the `operation` (`equal`, `delete`, `insert`) and the `text` of the line.
* **`customize_diff_output_html`:** This function takes the `diff_operations` and constructs an HTML unordered list (`
- \n"
for item in diff_operations:
operation = item['operation']
text = item['text']
if operation == 'equal':
html_output += f"
- {text} \n" elif operation == 'delete': # Use
- {text} \n' elif operation == 'insert': # Use for inserted text, with a green color for emphasis html_output += f'
- {text} \n' html_output += "
| Original | Modified |
|---|---|
| Operation | Content |
|---|---|
| = | {text} |
| - | {text} |
| + | {text} |
- `).
* `
- ` tags are used for each line.
* Inline `style` attributes are applied:
* Deleted lines get `color: red; text-decoration: line-through;` to visually mark them as removed.
* Inserted lines get `color: green;` to highlight new content.
* Equal lines are rendered normally.
* **`customize_diff_output_table`:** This function demonstrates creating a simple HTML table.
* It uses CSS classes (`delete-row`, `insert-row`, `equal-row`) for styling, which is a more maintainable approach than inline styles.
* Each row in the table represents a line from the diff, with an indicator (`-`, `+`, `=`) and the content.
This approach allows for complete control over how each type of change is presented, enabling the use of color, font styles, and even semantic HTML tags like `
` and `` for better accessibility and SEO. #### Scenario 2: Side-by-Side Comparison with Advanced Rendering True side-by-side comparison is a common requirement for code review and configuration management. While `text-diff` itself calculates the differences, rendering them side-by-side often involves a separate step or a specialized library. Python's `difflib` can be used to generate unified diffs, which can then be processed. For a more sophisticated side-by-side rendering, especially in a web context, JavaScript libraries are often employed. However, we can simulate a table-based side-by-side representation by carefully processing the diff operations. A robust side-by-side renderer needs to: 1. Identify blocks of changes. 2. Align unchanged lines between blocks. 3. Present added lines in the right column and deleted lines in the left column. Let's consider a simplified Python approach to generate HTML that *mimics* side-by-side. A truly perfect side-by-side often requires a more complex algorithm that reconstructs the state of both files line by line, filling in gaps with unchanged lines. For practical purposes, many cybersecurity tools integrate with front-end JavaScript libraries (like `diff2html`) that handle this rendering after the `text-diff` library has computed the differences. If you are building a custom UI, you would typically: 1. Compute the diff using a library. 2. Format the diff output into a standard format (e.g., JSON, unified diff). 3. Pass this formatted output to a JavaScript diff renderer on the client-side. However, for a server-side generation of HTML, we can try to create a table where each row represents a logical comparison point. python import difflib def get_unified_diff(text1, text2): """ Generates a unified diff string using Python's difflib. """ lines1 = text1.splitlines() lines2 = text2.splitlines() diff = difflib.unified_diff(lines1, lines2, lineterm='') return "\n".join(diff) def render_unified_diff_side_by_side_html(unified_diff_string): """ Renders a unified diff string into an HTML table for side-by-side comparison. This is a simplified renderer. More advanced versions handle context lines better. """ html_output = """
""" return html_output # Example Usage: text1 = """ # Configuration for web server server_name example.com; listen 80; ssl_certificate /etc/ssl/certs/example.com.crt; ssl_certificate_key /etc/ssl/private/example.com.key; root /var/www/example.com/html; index index.html index.htm; error_log /var/log/nginx/example.com.error.log; access_log /var/log/nginx/example.com.access.log; """ text2 = """ # Updated configuration for web server server_name example.com; listen 443 ssl; # Changed to SSL port ssl_certificate /etc/ssl/certs/example.com.crt; ssl_certificate_key /etc/ssl/private/example.com.key; root /var/www/example.com/html; index index.html index.htm; # Logging settings updated error_log /var/log/nginx/example.com.error.log warn; # Changed log level access_log /var/log/nginx/example.com.access.log combined; # Changed format keepalive_timeout 65; """ unified_diff = get_unified_diff(text1, text2) print("--- Unified Diff Output ---") print(unified_diff) print("\n") side_by_side_html = render_unified_diff_side_by_side_html(unified_diff) print("--- Side-by-Side HTML Rendered Output ---") print(side_by_side_html) print("\n") **Explanation:** * **`get_unified_diff`:** This uses `difflib.unified_diff` to produce a standard unified diff format, which is commonly understood by diff tools and libraries. * **`render_unified_diff_side_by_side_html`:** This is a more complex renderer. * It defines CSS for styling different types of diff lines (added, removed, unchanged, context). * It iterates through the lines of the unified diff. * It attempts to group lines into logical "rows" for the table. * For each conceptual row, it populates the left and right `Original File Modified File ... {current_left_cell_content} {current_right_cell_content} ` elements. * **Crucially:** A truly robust side-by-side renderer is complex. This example simplifies the parsing of hunks and line alignment. For production use, integrating with a dedicated JavaScript library on the front-end after generating a machine-readable diff (like JSON) is often more practical. The provided Python code attempts to create an HTML table that *represents* the side-by-side diff. It infers the class of each cell based on the prefix (`+`, `-`, ` `). #### Scenario 3: Integrating with Semantic HTML5 for Accessibility and SEO For security reports, audit logs, or any publicly accessible content, using semantic HTML5 tags is vital. `text-diff` results, when rendered as HTML, can leverage these tags effectively. * **`` (Insertion):** Use for lines or text that have been added. * **` ` (Deletion):** Use for lines or text that have been removed. * **``:** Wrap code snippets or configuration lines within `` tags for proper semantic representation. * **`pre`:** Use `` tags to preserve whitespace and line breaks in code or log entries, often in conjunction with `
`. python def customize_diff_output_semantic_html(diff_operations): """ Customizes the text-diff output into an HTML list using semantic tags. """ html_output = "- \n"
for item in diff_operations:
operation = item['operation']
text = item['text']
if operation == 'equal':
html_output += f"
{text}\n"
elif operation == 'delete':
# Use {text}\n'
elif operation == 'insert':
# Use for inserted text, wrap in {text}\n'
html_output += "
for deleted text, wrap inhtml_output += f'html_output += f'` tags for all lines. For deleted lines, it uses `` and for inserted lines, it uses ``. This makes the diff output more meaningful to browsers, assistive technologies, and search engines. #### Scenario 4: Customizing Output for Specific Data Formats (JSON, XML) In cybersecurity, results are often ingested by other systems. Customizing `text-diff` output into structured formats like JSON or XML is crucial for integration. python import json def customize_diff_output_json(diff_operations): """ Customizes the text-diff output into a JSON array of objects. """ return json.dumps(diff_operations, indent=2) # Using the same diff_ops from Scenario 1 customized_json = customize_diff_output_json(diff_ops) print("--- Customized JSON Output ---") print(customized_json) print("\n") # For XML, a similar process would involve building an XML string. def customize_diff_output_xml(diff_operations): """ Customizes the text-diff output into an XML string. """ xml_output = "\n" for item in diff_operations: operation = item['operation'] text = item['text'] # Basic escaping for XML special characters escaped_text = text.replace('&', '&').replace('<', '<').replace('>', '>') xml_output += f' <{operation}>\n' xml_output += " " return xml_output customized_xml = customize_diff_output_xml(diff_ops) print("--- Customized XML Output ---") print(customized_xml) print("\n") **Explanation:** * **`customize_diff_output_json`:** Simply uses `json.dumps` to convert the list of dictionaries directly into a well-formatted JSON string. * **`customize_diff_output_xml`:** This function constructs an XML string. * Each diff operation (`insert`, `delete`, `equal`) becomes an XML tag. * The text content is placed within a CDATA section (``) to avoid issues with special characters within the text that might otherwise break the XML structure. Basic XML escaping is also applied as a fallback. #### Scenario 5: Integrating with Markdown for Documentation and Reporting Markdown is widely used for documentation and reports. Customizing `text-diff` output into Markdown involves using Markdown's syntax for emphasis and code blocks. python def customize_diff_output_markdown(diff_operations): """ Customizes the text-diff output into Markdown format. """ markdown_output = "" for item in diff_operations: operation = item['operation'] text = item['text'] if operation == 'equal': markdown_output += f"`{text}`\n" # Inline code elif operation == 'delete': markdown_output += f"- ~~`{text}`~~\n" # Strikethrough with inline code elif operation == 'insert': markdown_output += f"+ `*{text}*`\n" # Bold with inline code (Markdown doesn't have a direct 'insert' syntax) # Alternative for insert: using code block with explicit marker # markdown_output += f"+ {text}\n" return markdown_output # Using the same diff_ops from Scenario 1 customized_markdown = customize_diff_output_markdown(diff_ops) print("--- Customized Markdown Output ---") print(customized_markdown) print("\n") **Explanation:** * **`customize_diff_output_markdown`:** * `equal` lines are wrapped in backticks (` `) for inline code. * `delete` lines use strikethrough (`~~`) and inline code. * `insert` lines use asterisks (`*`) for bolding and inline code. Markdown doesn't have a direct equivalent of `` or ``, so these are stylistic approximations. ### Technical Considerations for Advanced Customization * **Diff Algorithms:** The choice of diff algorithm can impact the output granularity. Libraries often offer different algorithms (e.g., Myers diff, patience diff). Understanding these can influence how easily you can achieve specific visual effects. * **Context Lines:** Diff outputs typically include context lines (lines that are the same but shown to provide surrounding information). How these are handled in rendering is crucial for readability. * **Line Wrapping and Truncation:** For long lines, you might need to implement line wrapping or truncation in your custom renderer to maintain layout integrity. * **Performance:** For very large files, the diff computation and subsequent rendering can be performance-intensive. Optimization might be necessary. * **Client-Side vs. Server-Side Rendering:** For interactive web UIs, client-side rendering (using JavaScript libraries) offers a more dynamic and responsive experience. Server-side rendering is suitable for static reports or when client-side scripting is restricted. ## 5+ Practical Scenarios in Cybersecurity The ability to customize `text-diff` output is not an academic exercise; it has tangible benefits across various cybersecurity domains. ### Scenario 1: Vulnerability Analysis in Configuration Files **Problem:** Auditors and security engineers often need to compare configuration files (e.g., `sshd_config`, `nginx.conf`, firewall rules) against a secure baseline or previous versions to detect unauthorized or insecure changes. Default diff output can be noisy and hard to scan for critical security parameters. **Customization Solution:** Render diffs with: * **Color-coding:** Highlight changes to security-sensitive parameters (e.g., `PermitRootLogin`, `SSLProtocol`, `AllowUser`) in red (deleted) or green (added). * **Semantic HTML:** Use `` and `` tags for added/removed parameters. * **Filtering:** Optionally, filter out changes to non-security parameters to focus solely on critical settings. * **Table View:** Present changes in a structured table with columns for "Parameter," "Old Value," and "New Value." **Example:** Imagine a `sshd_config` diff. A custom renderer could highlight `PermitRootLogin yes` being changed to `PermitRootLogin no` in a clear, unmistakable green. ### Scenario 2: Incident Response Log Analysis **Problem:** During an incident, analysts need to compare log files from different systems or time periods to identify anomalies or the sequence of events. Raw log diffs can be overwhelming. **Customization Solution:** * **Side-by-Side Log Comparison:** Present logs from a compromised system next to logs from a known good system, highlighting discrepancies in timestamps, IP addresses, or command executions. * **Highlighting Malicious Patterns:** Use regex-based styling to highlight known malicious IPs, command strings, or error messages within the diff. * **Structured Output (JSON/XML):** Convert diff results into JSON for ingestion by SIEM platforms, where specific fields can be parsed and alerted on. **Example:** Comparing two Nginx access logs might reveal an attacker's IP address making repeated requests in one log that are absent in the other. A custom diff could highlight these specific IP addresses and their associated requests in a distinct color. ### Scenario 3: Code Review for Security Vulnerabilities **Problem:** Developers and security researchers review code for potential vulnerabilities (e.g., SQL injection, buffer overflows). Standard diffs show code changes, but emphasizing security-critical code modifications is key. **Customization Solution:** * **Semantic HTML:** Use `` for new code and `` for removed code. Wrap code lines in ``. * **Highlighting Vulnerable Patterns:** Integrate static analysis tool (SAST) findings with the diff. If a SAST tool flags a new line of code as potentially vulnerable, the diff renderer can highlight that specific `` tag in a warning color (e.g., orange). * **Contextual Diff:** Ensure sufficient context lines are displayed to understand the surrounding logic of a change. * **Markdown for Reports:** Generate Markdown reports of code reviews, clearly marking added and removed code sections. **Example:** If a new function is added that uses unsanitized user input to construct a database query, the `` tag for that entire function could be highlighted in red, indicating a potential security risk. ### Scenario 4: Configuration Drift Detection and Auditing **Problem:** Maintaining consistent configurations across multiple servers is vital. Configuration drift (unauthorized changes) can introduce security gaps. **Customization Solution:** * **Automated Reporting:** Generate HTML reports of configuration diffs, clearly indicating drift from the baseline. * **Visual Indicators:** Use icons or color banners to denote the severity of changes (e.g., critical security setting changed vs. minor aesthetic change). * **Side-by-Side Comparison:** For critical configurations, provide a side-by-side view of the baseline and the current configuration. * **Audit Trail:** Store customized diff outputs as part of an audit trail, making it easy to track what changed, when, and by whom. **Example:** A report might show that a firewall rule was inadvertently deleted on a production server, marked with a prominent red `del` indicator and a brief explanation of the rule's purpose. ### Scenario 5: Policy and Rulebase Comparison **Problem:** Security policies, access control lists (ACLs), and intrusion detection system (IDS) rulebases are constantly updated. Ensuring these updates are correct and don't introduce unintended consequences is critical. **Customization Solution:** * **Rule-Specific Highlighting:** If a rule is added, deleted, or modified, highlight the entire rule block. * **Parameter-Level Diff:** For complex rules with many parameters, a more granular diff that highlights changes to individual parameters within a rule can be beneficial. * **Clear Add/Delete Markers:** Use distinct visual cues for added and deleted rules. * **Integration with Rule Management Systems:** Output diffs in formats compatible with rule management platforms. **Example:** Comparing two versions of an IDS rulebase. If a rule that blocks a known exploit is inadvertently removed, the diff would clearly show this removal in red, along with the rule's description. ### Scenario 6: Software Bill of Materials (SBOM) Analysis **Problem:** SBOMs list the components of software. Comparing SBOMs from different versions of an application can reveal new dependencies, which might introduce new vulnerabilities or licensing issues. **Customization Solution:** * **Component-Level Diff:** Highlight new components added, components removed, and changes in component versions. * **Vulnerability Data Integration:** If vulnerability databases are available, highlight components that have known vulnerabilities in the new SBOM but not in the old one. * **License Compliance:** Highlight changes in component licenses that might violate organizational policies. * **Structured Output:** Output the diff in JSON or other formats for automated ingestion and analysis by software supply chain security tools. **Example:** An SBOM diff might show that a new library, which has recently been associated with a critical CVE, has been added to the application. This would be highlighted prominently. ## Global Industry Standards and Best Practices While `text-diff` itself is a tool, its application and the desired appearance of its results are influenced by broader industry standards and best practices in cybersecurity and information management. * **NIST SP 800-53:** This framework for security and privacy controls emphasizes **audit and accountability**. Customized diff outputs, especially when presented in structured formats like logs or reports, contribute to audit trails by clearly showing system changes. * **ISO 27001:** This standard for information security management systems (ISMS) mandates **change management**. Customized diffs are invaluable for documenting and verifying changes to configurations, code, and policies, ensuring they are authorized and secure. * **OWASP (Open Web Application Security Project):** OWASP's guidelines, particularly for secure coding and application security testing, implicitly rely on effective code diffing. Customization that highlights insecure code additions or deletions directly supports OWASP's recommendations. * **RFC 2068 (HTTP/1.1) and subsequent RFCs:** While not directly about diffing, these standards define how data is transmitted and presented. Semantic HTML (``, ``) aligns with web standards for conveying meaning and improving accessibility, which is relevant when diffs are presented via web interfaces. * **Common Vulnerabilities and Exposures (CVE) and Common Weakness Enumeration (CWE):** When analyzing code or configurations for known vulnerabilities, the ability to customize diffs to highlight patterns associated with CVEs or CWEs significantly enhances the efficiency of vulnerability assessment. * **CIS Benchmarks:** The Center for Internet Security (CIS) provides hardening guidelines for various systems. Comparing system configurations against CIS benchmarks often involves diffing. Customized diffs that clearly show deviations from these secure baselines are essential for compliance. * **Data Serialization Standards (JSON, XML):** The widespread adoption of JSON and XML as interchange formats in cybersecurity tools (SIEMs, SOAR platforms, vulnerability scanners) means that customizing `text-diff` output into these formats is a de facto industry standard for interoperability. Adhering to these standards means that the way `text-diff` results are presented should not just be visually appealing but also functionally aligned with the principles of security, auditability, and compliance. ## Multi-language Code Vault The principles of text diffing and customization are language-agnostic. However, the implementation details and the specific libraries used will vary. Below is a conceptual outline of how customization might be approached in different programming languages, demonstrating the universality of the need for tailored diff output. ### Python (as detailed above) * **Libraries:** `difflib`, `diff_match_patch` (Google's library), `textdistance`. * **Customization:** Post-processing the library output to generate HTML, JSON, XML, Markdown, or plain text with custom markers. ### JavaScript (for Web Front-ends) * **Libraries:** `diff`, `diff2html`, `jsdiff`. * **Customization:** Primarily through client-side rendering. Libraries like `diff2html` are specifically designed to take diff outputs (e.g., from Git) and render them as highly customizable HTML tables with side-by-side views, line highlighting, and various themes. This is ideal for web-based security dashboards or code review platforms. javascript // Conceptual JavaScript Example (using a hypothetical diff library output) // In a real scenario, you'd use a library like 'diff' or 'jsdiff' const diffResult = [ { type: 'equal', value: 'Line 1 of original' }, { type: 'delete', value: 'Line 2 removed' }, { type: 'insert', value: 'Line 3 added' }, { type: 'equal', value: 'Line 4 of original' } ]; function customizeDiffJs(diffArray) { let html = '- ';
diffArray.forEach(item => {
let className = '';
let tag = 'span';
if (item.type === 'delete') {
className = 'deleted';
tag = 'del';
} else if (item.type === 'insert') {
className = 'inserted';
tag = 'ins';
} else {
className = 'equal';
}
html += `
- <${tag}>${item.value} `; }); html += '
originalLines = Arrays.asList("Line 1", "Line 2", "Line 3"); List revisedLines = Arrays.asList("Line 1", "Line 3", "Line 4"); Patch patch = DiffUtils.diff(originalLines, revisedLines); List