# Changelog

All notable changes to similar are documented here.

## Unreleased

## 3.1.2

* Fixed `Algorithm::Lcs` deadline fallback emitting edits twice, which produced
  out-of-bounds `DiffOp` ranges and panics when consuming timed-out diffs.  #97
* Fixed `Algorithm::Lcs` reporting identical subranges with zero-based indices
  instead of preserving the supplied range offsets.  #98
* Fixed `Algorithm::Lcs` and `Algorithm::Hunt` emitting zero-length delete
  operations when both inputs are empty.  #99

## 3.1.1

* Fixed `DiffOp` cursor positions when compacting adjacent inserts/deletes and
  in `Algorithm::Histogram` full-replacement output, ensuring operations form
  contiguous ranges.  #95
* Renamed sample diff input files to a lexicographic
  `caseNN.01.before_*` / `caseNN.02.after_*` scheme.

## 3.1.0

* Added `capture_diff_slices_by_key` and `capture_diff_slices_by_key_deadline`
  as convenience helpers for diffing slices by derived keys.
* Fixed `Compact` emitting inconsistent `DiffOp` cursor positions after
  compaction, which could leave `Delete`/`Insert` operations with stale
  `new_index`/`old_index` values.
* Added explicit lifetime capture (`+ use<...>`) on iterator-returning APIs to
  improve compatibility with Rust 2024 lifetime capture behavior.  #93

## 3.0.0

* Added a Git-style Histogram diff implementation exposed as
  `Algorithm::Histogram`, including deadline-aware Myers fallback and
  comprehensive regression/behavior tests.
* Raised MSRV to Rust 1.85 and moved the crate to Rust 2024 edition.
* Added a Hunt-style diff implementation exposed as `Algorithm::Hunt`.
* Added configurable inline refinement via `InlineChangeOptions` and
  `InlineChangeMode`, including semantic cleanup and new
  `TextDiff::iter_inline_changes_with_options*` methods.  #92
* Added a global disjoint-input fast path in `algorithms::diff_deadline`
  to avoid pathological runtimes on large, fully distinct inputs.
* Improved `Algorithm::Myers` performance on heavily unbalanced diffs to
  avoid pathological slowdowns.
* Added `diff_deadline_raw` entrypoints in the algorithm modules to bypass
  shared heuristics and keep minimal intrinsic trait bounds where needed.
* Added test files in `examples/diffs` that can be used with the some of the
  examples as input pairs.
* Added `CachedLookup`, a helper for adapting virtual or computed sequences by
  materializing items on first access and then serving borrowed values through
  normal indexing.  The `owned-lookup` example demonstrates this approach for
  issue #33.
* Fixed ranged indexing in the classic LCS table algorithm.
* Improved diff compaction to merge adjacent delete hunks across equal runs.
* Excluded development scripts from published crate contents.  #87
* `TextDiff::from_*` and `TextDiffConfig::diff_*` now accept owned inputs
  (`String`, `Vec<u8>`, `Cow`) in addition to borrowed inputs.  This allows
  returning text diffs from functions without external owner lifetimes.  #65
* `TextDiff` no longer exposes `old_slices` / `new_slices`.  Use
  `old_len`, `new_len`, `old_slice`, `new_slice`, `iter_old_slices`,
  `iter_new_slices`, `old_lookup`, and `new_lookup` instead.
* `TextDiff::iter_changes` now panics on invalid out-of-bounds `DiffOp`
  ranges instead of silently truncating iteration.
* `utils::diff_lines_inline` now takes `&TextDiff` and options rather than
  `(Algorithm, old, new, options)`.
* `utils::diff_lines` now avoids a second line-tokenization pass.
* Renamed `get_diff_ratio` to `diff_ratio`.
* Added first-class `no_std + alloc` support with an explicit default `std`
  feature.
* Added optional `hashbrown` backend for `no_std` map storage
  (`default-features = false, features = ["hashbrown"]`), while the default
  `no_std` backend uses `alloc::collections::BTreeMap`.
* Made core constructors const-ready (`Capture::new`, `Replace::new`,
  `NoFinishHook::new`, `InlineChangeOptions::new`, `TextDiff::configure`).

## 2.7.0

* Add optional support for `web-time` to support web WASM targets.  #73
* Crate will no longer panic wheh deadlines are used in WASM.  At worst
  deadlines are silently ignored.  To enforce deadlines enable the
  `wasm32_web_time` feature.  #74

## 2.6.0

* Bump bstr dependency to 1.5.  #69

## 2.5.0

* Added support for `TextDiff::iter_inline_changes_deadline`.  #61
* Raise MSRV to 1.60.  #62
* Bump bstr dependency to 1.0.  #62

## 2.4.0

* Fixed a bug where the LCS diff algorithm didn't always call `D::finish`.  (#58)
* Fixed a bug in LCS that caused a panic if the common prefix and the
  common suffix overlapped.  (#59)

## 2.3.0

* Added support for `Change::value_ref` and `Change::value_mut`.

## 2.2.1

* Fixed a panic in LCS diffs on matching input.  (#43)

## 2.2.0

* Fixed a panic in text diff generation. (#37)

## 2.1.0

* Removed deprecated alternative slice diffing functions.
* Added `serde` feature to allow serialization with serde.

## 2.0.0

* Change the `Change` type and associated methods to work on any `T: Clone` instead
  of `&T`.  This makes the `iter_changes` method also work on slices of integers
  or other values.

## 1.3.0

* Performance improvements for the LCS algorithm.
* Small performance improvements by adding an early opt-out for and inline highlighting.
* Added `IdentifyDistinct` to convert sequences to ints.
* Small performance improvements for larger text diffs by using `IdentifyDistinct`
  automatically above a threshold.
* Added deadlines to all diffing algorithms to bail early.
* Deprecated slice diffing methods in the individual algorithm modules.
* Use a default timeout for the inline highlighting feature.
* Added a compacting step to clean up diffs.  This results in nicer looking diffs and
  fewer edits.  This is happening automatically for captured diffs and is exposed
  through the `Capture` type.
* Fix incorrect ranges in unified diff output.

## 1.2.2

* Added support for Rust 1.41.0 for better compatibility.

## 1.2.1

* Added support for Rust 1.43.0 for better compatibility.

## 1.2.0

* Make the unicode feature optional for inline diffing.
* Added Hunt–McIlroy LCS algorithm (`lcs`).
* Changed the implementation of Mayer's diff.  This has slightly changed the
  behavior but resulted in significantly improved performance and more
  readable code.
* Added `NoFinishHook` to aid composing of diff hooks.

## 1.1.0

* More generic lifetimes for `iter_changes` and `iter_inline_changes`.
* Added `iter_all_changes` shortcut as this is commonly useful.
* Added `iter_slices` to `DiffOp` to quickly get an iterator over the
  encoded slices rather than individual items like `iter_changes` does.
* Added the `utils` module with various text diffing utilities.
* Added `TextDiffRemapper` which helps with working with the original, pre
  `TextDiff` tokenization slices.

## 1.0.0

* Add `get_diff_ratio`.
* Add support for byte diffing and change the text interface to abstract
  over `DiffableStr`.
* Restructured crate layout greatly.  Text diffing is now on the crate root,
  some functionality remains in the algorithms.
* The `Change` type now also works for non text diffs.

## 0.5.0

* Add `DiffOp::apply_to_hook` to apply a captured op to a diff hook.
* Added missing newline handling to the `Changes` type.
* Made unified diff support more flexible through the introduction of
  the `UnifiedDiff` type.
* Fixed grouped diff operation to return an empty result if the diff
  does not show any changes.
* Added inline diff highlighting support.
* Changed word splitting to split into words and whitespace.
* Added support for unicode based word splitting (`TextDiff::from_unicode_words`).

## 0.4.0

* Change `get_close_matches` to use Python's quick ratio optimization
  and order lexicographically when tied.

## 0.3.0

* Added grapheme and character level diffing utilities.
* `DiffOp::as_tag_tuple` is now taking the argument by reference.
* Added `TextDiff::ratio`.
* Added `get_close_matches`.

## 0.2.0

* Fixed a bug in the patience algorithm causing it not not work.

## 0.1.0

* Initial release.
