Struct DiffHunk 

pub struct DiffHunk {
    pub old_start: usize,
    pub old_count: usize,
    pub new_start: usize,
    pub new_count: usize,
    pub context: Option<String>,
    pub lines: Vec<DiffLine>,
}

Represents a single hunk (section) in a diff.

A hunk contains the line range information and a collection of lines that make up this section of the diff. The header information (old_start, old_count, new_start, new_count) corresponds to the unified diff format: @@ -old_start,old_count +new_start,new_count @@ context

Fields

• old_start - Starting line number in the old file
• old_count - Number of lines from the old file in this hunk
• new_start - Starting line number in the new file
• new_count - Number of lines from the new file in this hunk
• context - Optional context text (e.g., function name) shown in the header
• lines - The actual diff lines in this hunk

Fields

old_start: usize

Starting line number in the old/original file.

old_count: usize

Number of lines from the old file included in this hunk.

new_start: usize

Starting line number in the new/modified file.

new_count: usize

Number of lines from the new file included in this hunk.

context: Option<String>

Optional context text from the hunk header (e.g., function name).

lines: Vec<DiffLine>

The lines in this hunk, including context, added, and removed lines.

Implementations

impl DiffHunk

pub fn from_header(header: &str) -> Option<Self>

Creates a new diff hunk by parsing a unified diff header line.

Parses headers in the format: @@ -old_start,old_count +new_start,new_count @@ context

Arguments

• header - The hunk header line to parse

Returns

Some(DiffHunk) if parsing succeeds, None otherwise

Example

use ratatui_toolkit::code_diff::DiffHunk;

let hunk = DiffHunk::from_header("@@ -1,4 +1,5 @@ fn main()").unwrap();
assert_eq!(hunk.old_start, 1);
assert_eq!(hunk.old_count, 4);
assert_eq!(hunk.new_start, 1);
assert_eq!(hunk.new_count, 5);
assert_eq!(hunk.context.as_deref(), Some("fn main()"));

impl DiffHunk

pub fn new( old_start: usize, old_count: usize, new_start: usize, new_count: usize, ) -> Self

Creates a new diff hunk with the specified line ranges.

Arguments

• old_start - Starting line number in the old file
• old_count - Number of lines from the old file
• new_start - Starting line number in the new file
• new_count - Number of lines from the new file

Returns

A new DiffHunk with empty lines and no context

Example

use ratatui_toolkit::code_diff::DiffHunk;

let hunk = DiffHunk::new(1, 4, 1, 5);
assert_eq!(hunk.old_start, 1);
assert_eq!(hunk.old_count, 4);

impl DiffHunk

pub fn add_line(&mut self, line: DiffLine)

Adds a diff line to this hunk.

Arguments

• line - The diff line to add

Example

use ratatui_toolkit::code_diff::{DiffHunk, DiffLine};

let mut hunk = DiffHunk::new(1, 2, 1, 3);
hunk.add_line(DiffLine::context("unchanged", 1, 1));
hunk.add_line(DiffLine::added("new line", 2));

impl DiffHunk

pub fn added_count(&self) -> usize

Returns the number of added lines in this hunk.

Returns

The count of lines with DiffLineKind::Added

Example

use ratatui_toolkit::code_diff::{DiffHunk, DiffLine};

let mut hunk = DiffHunk::new(1, 2, 1, 3);
hunk.add_line(DiffLine::added("new line 1", 1));
hunk.add_line(DiffLine::added("new line 2", 2));
assert_eq!(hunk.added_count(), 2);

impl DiffHunk

pub fn header_text(&self) -> String

Returns the formatted header text for this hunk.

Generates a unified diff style header like @@ -1,4 +1,5 @@ context.

Returns

The formatted header string

Example

use ratatui_toolkit::code_diff::DiffHunk;

let mut hunk = DiffHunk::new(1, 4, 1, 5);
assert_eq!(hunk.header_text(), "@@ -1,4 +1,5 @@");

impl DiffHunk

pub fn removed_count(&self) -> usize

Returns the number of removed lines in this hunk.

Returns

The count of lines with DiffLineKind::Removed

Example

use ratatui_toolkit::code_diff::{DiffHunk, DiffLine};

let mut hunk = DiffHunk::new(1, 3, 1, 2);
hunk.add_line(DiffLine::removed("old line 1", 1));
hunk.add_line(DiffLine::removed("old line 2", 2));
assert_eq!(hunk.removed_count(), 2);

Trait Implementations

impl Clone for DiffHunk

fn clone(&self) -> DiffHunk

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DiffHunk

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for DiffHunk

fn eq(&self, other: &DiffHunk) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for DiffHunk

impl StructuralPartialEq for DiffHunk