HTMLDiff

The :merge_threshold option controls how much unchanged text is grouped with changes.

• Higher value: Produces "chunkier" diffs (more words grouped into a single <ins> or <del> block).
• Lower value (e.g., 0): Produces "choppier" diffs (more granular changes).
• false or -1: Disables merging across whitespace (will still merge whitespace itself).

# Granular/choppy diff
diff = HTMLDiff.diff(old_text, new_text, merge_threshold: 0)

HTMLDiff operates in three distinct stages:

1. Tokenization: The input strings are split into an array of tokens (via HTMLDiff::Tokenizer).
2. Diff Generation: The HTMLDiff::Differ module uses the LCS (Longest Common Subsequence) algorithm to identify differences between token arrays.
3. Formatting: The differences are converted into the final output format by a formatter.

Version 1.0.0 maintains the basic HTMLDiff.diff(a, b) API syntax but introduces changes to default HTML output, class structures, and the underlying diff algorithm.

Key changes include:

• Simplified HTML Tags: Default output now uses plain <ins> and <del> tags without CSS classes.
• Class Refactoring: HTMLDiff::DiffBuilder is deprecated. Use the top-level HTMLDiff.diff method instead.
• Algorithm Update: The engine now uses the diff-lcs gem, which may produce slightly different diff results compared to older versions.

Add the htmldiff gem to your application's Gemfile to use it in your Ruby project.

gem 'htmldiff'

Use HTMLDiff.diff(old_text, new_text) to generate an HTML-formatted diff between two strings. By default, it uses <del> and <ins> tags to highlight deletions and insertions.

require 'htmldiff'

old_text = "The quick red fox jumped over the dog."
new_text = "The red fox hopped over the lazy dog."

diff = HTMLDiff.diff(old_text, new_text)

In version 1.0.0, the default output no longer includes the diffins, diffdel, and diffmod classes. To restore the exact HTML output format used in version 0.0.1, pass a configuration hash to the html_format: option in the HTMLDiff.diff method.

html_format = { class_insert: 'diffins', class_delete: 'diffdel', class_replace: 'diffmod' }
HTMLDiff.diff(old_text, new_text, html_format: html_format)

You can control the HTML tags and CSS classes used for diff elements by passing an html_format hash to HTMLDiff.diff. This allows you to override default tags (like del and ins) and apply specific CSS classes for deletions, insertions, and replacements.

diff = HTMLDiff.diff(old_text, new_text, html_format: {
  tag: 'span',
  class_delete: 'highlight removed',
  class_insert: 'highlight added'
})

The HTMLDiff::DiffBuilder class is deprecated in version 1.0.0 and will raise a warning when used. You should replace direct builder instantiation with the simplified HTMLDiff.diff method.

# Old (Deprecated)
HTMLDiff::DiffBuilder.new(a, b).build

# Replace with
HTMLDiff.diff(a, b)

You can control the granularity of the diff by providing a tokenizer object that responds to #tokenize. The method should return an Array of strings.

Note: Your tokenizer must include whitespace tokens so that the resulting tokens can be joined back into the original string exactly.

module MyCustomTokenizer
  def self.tokenize(string)
    string.split(/(\b|\s)/).reject(&:empty?)
  end
end

diff = HTMLDiff.diff(old_text, new_text, tokenizer: MyCustomTokenizer)

To change how the diff output is rendered (e.g., to use a different markup language or CSS classes), provide an object that implements a format method to the formatter option.

class MyCustomFormatter
  def format(changes)
    # Implement custom rendering logic based on changes
    "Custom Diff: #{changes.inspect}"
  end
end

HTMLDiff.diff(old_str, new_str, formatter: MyCustomFormatter.new)