@spec bisect(String.t(), String.t(), expiry()) :: difflist()

Find the "middle snake" of a diff, split the problem in two and return the recursively constructed diff.

See: An O(ND) Difference Algorithm and Its Variations (Meyers, 1986)

• text1 - Old string to be diffed.
• text2 - New string to be diffed.
• deadline - Unix timestamp (in milliseconds) at which to bail if not yet complete.

Returns a difflist.

@spec bisect_split(
  String.t(),
  String.t(),
  non_neg_integer(),
  non_neg_integer(),
  non_neg_integer()
) :: difflist()

Given the location of the "middle snake", split the diff in two parts and recurse.

• text1 - Old string to be diffed.
• text2 - New string to be diffed.
• x - Index of split point in text1.
• y - Index of split point in text2.
• deadline - Unix timestamp (in milliseconds) at which to bail if not yet complete.

Returns a difflist.

@spec chars_to_lines(difflist(), [String.t()]) :: difflist()

Rehydrate the text in a diff from a string of line hashes to real lines of text.

• diffs - A difflist.
• line_array - A list of unique strings.

Returns the rehydrated difflist.

@spec cleanup_efficiency(difflist(), non_neg_integer()) :: difflist()

Reduce the number of edits in a diff by eliminating operationally trivial equalities.

• diff_edit_cost Cost of an empty edit operation in terms of edit characters.

Returns the updated difflist.

@spec cleanup_merge(difflist()) :: difflist()

Reorder and merge like edit sections in a diff, merging equalities.

Any edit section can move as long as it doesn't cross an equality.

Returns the updated difflist.

@spec cleanup_semantic(difflist()) :: difflist()

Reduce the number of edits in a diff by eliminating semantically trivial equalities.

Returns the updated difflist.

@spec cleanup_semantic_lossless(difflist()) :: difflist()

Look for single edits in a diff that are surrounded on both sides by equalities which can be shifted sideways to align the edit to a word boundary.

Example: The c<ins>at c</ins>ame. becomes The <ins>cat </ins>came.

Returns the updated difflist.

@spec common_overlap(String.t(), String.t()) :: non_neg_integer()

Determine if the suffix of one string is the prefix of another.

• text1 - First string.
• text2 - Second string.

Returns the number of characters common to the end of the first string and the start of the second string.

@spec common_prefix(String.t(), String.t()) :: {String.t(), String.t(), String.t()}

Determine the common prefix of two strings.

• text1 - First string.
• text2 - Second string.

Returns a tuple {prefix, rest1, rest2}, where

• prefix - The common prefix.
• rest1 - text1 with the prefix removed.
• rest2 - text2 with the prefix removed.

@spec common_suffix(String.t(), String.t()) :: {String.t(), String.t(), String.t()}

Determine the common suffix of two strings.

• text1 - First string.
• text2 - Second string.

Returns a tuple {suffix, rest1, rest2}, where

• suffix - The common suffix.
• rest1 - text1 with the suffix removed.
• rest2 - text2 with the suffix removed.

@spec compute(String.t(), String.t(), boolean(), expiry()) :: difflist()

Find the differences between two texts.

• text1 - Old string to be diffed.
• text2 - New string to be diffed.
• check_lines - Speedup flag. If false, then don't run a line-level diff first to identify the changed areas. If true, then run a faster slightly less optimal diff.
• deadline - Unix timestamp in milliseconds when the diff should be complete by.

Assumes that the texts do not have any common prefix or suffix.

Returns a difflist.

@spec from_delta(String.t(), String.t()) :: nil | difflist()

Given the original text1, and an encoded string which describes the operations required to transform text1 into text2, compute the full diff.

• text1 - Source string for the diff. *delta - Encoded delta text.

Returns a difflist.

Raises an ArgumentError if the encoded delta has invalid contents for the given text.

@spec half_match(String.t(), String.t(), non_neg_integer()) ::
  nil | half_match_result()

Do the two texts share a substring which is at least half the length of the longer text?

• text1 - First string.
• text2 - Second string.
• deadline - Unix timestamp (in milliseconds) at which to bail if not yet complete.

This speedup can produce non-minimal diffs.

Returns a half_match_result 5-tuple, or nil if there was no match. Returns nil if deadline is zero (no time limit specified).

@spec levenshtein(difflist()) :: non_neg_integer()

Compute the Levenshtein distance of a diff--the number of inserted, deleted or substituted characters.

@spec line_mode(String.t(), String.t(), expiry()) :: difflist()

Do a quick line-level diff on both strings, then rediff the parts for greater accuracy.

• text1 - Old string to be diffed.
• text2 - New string to be diffed.
• deadline - Unix timestamp (in milliseconds) when the diff should be complete by.

This speedup can produce non-minimal diffs.

Returns a difflist.

@spec lines_to_chars(String.t(), String.t()) :: {String.t(), String.t(), [String.t()]}

Split two texts into a list of strings.

Reduce the texts to a string of hashes where each Unicode character represents one line.

• text1 - First string.
• text2 - Second string.

Returns a tuple containing the encoded text1, the encoded text2 and the list of unique strings. The zeroth element of the list of unique strings is intentionally blank.

@spec main(String.t(), String.t(), boolean(), options()) :: difflist()

Find the differences between two texts.

• text1 - Old string to be diffed.
• text2 - New string to be diffed.
• check_lines - Speedup flag. If false, then don't run a line-level diff first to identify the changed areas. If true, then run a faster slightly less optimal diff.
• opts - A options keyword list, [] to use the default options.

Most of the time check_lines is wanted, so it defaults to true.

Returns a difflist.

@spec main_(String.t(), String.t(), boolean(), options()) :: difflist()

Skips validation of options. Used internally by Patch.apply.

@spec pretty_html(difflist()) :: String.t()

Generate a pretty HTML report from a difflist.

@spec semantic_score(String.t(), String.t()) :: non_neg_integer()

Given two strings, compute a score representing whether the internal boundary falls on logical boundaries.

Scores range from 6 (best) to 0 (worst).

• one - First string.
• two - Second string.

Scores are:

• 6 if one or two is an empty string.
• 5 if a blank line ends in one or a blank line starts in two.
• 4 if one ends, or two starts, with a newline.
• 3 if one ends in a punctuation and two starts with white space.
• 2 if one ends, or two starts, with white space.
• 1 if one ends, or two starts, with a non-alphanumeric.
• 0 otherwise

examples

Examples

iex> Diff.semantic_score("two is empty string", "")
6

iex> Diff.semantic_score("one ends in blank line\n\n", "two")
5

iex> Diff.semantic_score("one ends in new line\n", "two")
4

iex> Diff.semantic_score("one sentence.", " space before two")
3

iex> Diff.semantic_score("one sentence.", "no space before two")
1

iex> Diff.semantic_score("one ends with white space ", "two")
2

iex> Diff.semantic_score("one ends in 'punctuation'", "two")
1

iex> Diff.semantic_score("one ends in middle of word", "two")
0

@spec text1(difflist()) :: String.t()

Compute and return the source text of a diff (all equalities and deletions).

@spec text2(difflist()) :: String.t()

Compute and return the destination text of a diff (all equalities and insertions).

@spec to_delta(difflist()) :: String.t()

Crush a diff into an encoded string which describes the operations required to transform text1 into text2.

For example, "=3 -2 +ing" means keep 3 chars, delete 2 chars, insert "ing".

Operations are tab-separated. Inserted text is escaped using %xx notation.

examples

Examples

|> iex [{:equal, "abc"}, {:delete, "de"}, {:insert, "ing"}] |> to_delta() |> IO.inspect()
"=3\t-2\t+ing"

@spec undiff(nil | t()) :: t()

Returns the diff tuple, or a "nil" pseudo-diff (with op :nil and empty text).

@spec x_index(difflist(), non_neg_integer()) :: non_neg_integer()

Given loc, a location in text1, compute and return the equivalent location in text2.

• diffs - a difflist.
• loc - Location within text1.

Returns location within text2.

examples

Examples

iex> Diff.main("The cat", "The big cat") |> Diff.x_index(1)
1

iex> Diff.main("The cat", "The big cat") |> Diff.x_index(4)
8