"windows-sys 0.52.0",

version = "0.4.19"

checksum = "b06a4cde4c0f271a446782e3eff8de789548ce57dbc8eca9292c27f4a42004b4"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "d5fe953b25a8f5c24baf1019f746912e7453746d617a1af04cb347904d241005"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "0b362b0301c59fb94f4ead7bd7366c0668ac431c1fed8a9fe8fc88a64b03dc91"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "6e9c90efa7a3febd01d33ed2e72cb12296c971ce03efa243d11c01520fcc1be8"

 "once_cell",

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "d16d9e1403a6c3073dce14f3ed893f430bb67d7af6a07cc7fe4b81907025ba22"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "cb41c7e10ada3a4df960190a96bfb4af56d33ada890f917acc8e3b122b614875"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "d2bcf567e08ec477457dafd190a9785f368c9b86272a42c684db609510ebc456"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "fbee758010fb64482be4b18591fbeb3cbc15b16450d143edf4edb5484c7366c6"

 "byteorder",

 "log",

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "5fd82b00d1e729319fdeccc6a2e37158b01ad32cc8e4dbff40a612ca94a1e311"

 "libc",

 "shlex",

 "windows-sys 0.52.0",

 "windows-core",

 "windows-implement",

 "windows-interface",

 "windows-result",

radicle = { version = "0.16.1" }

radicle-term = { version = "0.13.0" }

radicle-cli = { version = "0.14.0" }

radicle-signals = { version = "0.11.0" }

radicle = { version = "0.16.1", features = ["test"] }

                        let builder = CommentBuilder::new(revision.head(), path.to_path_buf());

                    HunkItem::from((&repo, &review, item)),

use std::ops::{Not, Range};

use radicle::cob::{CodeLocation, CodeRange};

use radicle_cli::git::unified_diff::{Encode, HunkHeader};

use crate::git::HunkDiff;

                        hs.pop()

                        hs.pop()

                        for hunk in base_hunks {

                                hunk: Some(hunk),

    pub location: CodeLocation,

    pub fn new(commit: Oid, path: PathBuf) -> Self {

    pub fn edit(mut self, hunk: &Hunk<Modification>) -> Result<Vec<ReviewComment>, Error> {

        for line in hunk.to_unified_string()?.lines() {

            .initial(input)?

            let header = HunkHeader::try_from(hunk)?;

            self.add_hunk(header, &output);

    pub fn add_hunk(&mut self, hunk: HunkHeader, input: &str) -> &mut Self {

        let lines = input.trim().lines().map(|l| l.trim());

        let (mut old_line, mut new_line) = (hunk.old_line_no as usize, hunk.new_line_no as usize);

        let (mut old_start, mut new_start) = (old_line, new_line);

                    self.add_comment(

                        &hunk,

                        &comment,

                        old_start..old_line - 1,

                        new_start..new_line - 1,

                    );

                    old_start = old_line - 1;

                    new_start = new_line - 1;

                    comment.clear();

                }

                match line.trim_start_matches('>').trim_start().chars().next() {

                    Some('-') => old_line += 1,

                    Some('+') => new_line += 1,

                    _ => {

                        old_line += 1;

                        new_line += 1;

                &hunk,

                old_start..old_line - 1,

                new_start..new_line - 1,

    fn add_comment(

        &mut self,

        hunk: &HunkHeader,

        comment: &str,

        mut old_range: Range<usize>,

        mut new_range: Range<usize>,

    ) {

        // Top-level comment, it should apply to the whole hunk.

        if old_range.is_empty() && new_range.is_empty() {

            old_range = hunk.old_line_no as usize..(hunk.old_line_no + hunk.old_size + 1) as usize;

            new_range = hunk.new_line_no as usize..(hunk.new_line_no + hunk.new_size + 1) as usize;

        }

        let old_range = old_range

            .is_empty()

            .not()

            .then_some(old_range)

            .map(|range| CodeRange::Lines { range });

        let new_range = (new_range)

            .is_empty()

            .not()

            .then_some(new_range)

            .map(|range| CodeRange::Lines { range });

            location: CodeLocation {

                commit: self.commit,

                old: old_range,

                new: new_range,

                location: CodeLocation {

                    path: path.clone(),

                    old: Some(CodeRange::Lines { range: 2559..2565 }),

                    new: Some(CodeRange::Lines { range: 2560..2563 }),

                },

                location: CodeLocation {

                    path: path.clone(),

                    old: Some(CodeRange::Lines { range: 2565..2568 }),

                    new: Some(CodeRange::Lines { range: 2563..2567 }),

                },

                location: CodeLocation {

                    path: path.clone(),

                    old: Some(CodeRange::Lines { range: 2568..2571 }),

                    new: Some(CodeRange::Lines { range: 2567..2570 }),

                },

                location: CodeLocation {

                    path: path.clone(),

                    old: None,

                    new: Some(CodeRange::Lines { range: 2570..2571 }),

                },

                location: CodeLocation {

                    path: path.clone(),

                    old: Some(CodeRange::Lines { range: 2571..2577 }),

                    new: Some(CodeRange::Lines { range: 2571..2578 }),

                },

        let mut builder = CommentBuilder::new(commit, path.clone());

            HunkHeader {

                old_line_no: 2559,

                old_size: 18,

                new_line_no: 2560,

                new_size: 18,

                text: vec![],

            },

                location: CodeLocation {

                    path: path.clone(),

                    old: Some(CodeRange::Lines { range: 2559..2565 }),

                    new: Some(CodeRange::Lines { range: 2560..2563 }),

                },

                location: CodeLocation {

                    path: path.clone(),

                    old: Some(CodeRange::Lines { range: 2565..2568 }),

                    new: Some(CodeRange::Lines { range: 2563..2567 }),

                },

        let mut builder = CommentBuilder::new(commit, path.clone());

            HunkHeader {

                old_line_no: 2559,

                old_size: 9,

                new_line_no: 2560,

                new_size: 7,

                text: vec![],

            },

            location: CodeLocation {

                commit,

                path: path.clone(),

                old: Some(CodeRange::Lines { range: 2559..2569 }),

                new: Some(CodeRange::Lines { range: 2560..2568 }),

            },

        let mut builder = CommentBuilder::new(commit, path.clone());

            HunkHeader {

                old_line_no: 2559,

                old_size: 9,

                new_line_no: 2560,

                new_size: 7,

                text: vec![],

            },

            location: CodeLocation {

                path: path.clone(),

                old: Some(CodeRange::Lines { range: 2564..2565 }),

                new: Some(CodeRange::Lines { range: 2563..2564 }),

            },

        let mut builder = CommentBuilder::new(commit, path.clone());

            HunkHeader {

                old_line_no: 2559,

                old_size: 6,

                new_line_no: 2560,

                new_size: 4,

                text: vec![],

            },

use radicle_surf::diff::{Copied, DiffFile, EofNewLine, FileStats, Hunk, Modification, Moved};

use radicle_cli::git::unified_diff::FileHeader;

use serde::{Deserialize, Serialize};

impl From<&Hunk<Modification>> for HunkStats {

    fn from(hunk: &Hunk<Modification>) -> Self {

#[derive(Clone, PartialEq)]

        hunk: Option<Hunk<Modification>>,

        hunk: Option<Hunk<Modification>>,

        hunk: Option<Hunk<Modification>>,

    pub fn hunk(&self) -> Option<&Hunk<Modification>> {

impl Debug for HunkDiff {

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

        let (name, path, hunk) = match self {

            Self::Added { path, hunk, .. } => ("Added", path, hunk),

            Self::Deleted { path, hunk, .. } => ("Deleted", path, hunk),

            Self::Moved { moved } => ("Moved", &moved.new_path, &None),

            Self::Copied { copied } => ("Copied", &copied.new_path, &None),

            Self::Modified { path, hunk, .. } => ("Modified", path, hunk),

            Self::EofChanged { path, .. } => ("EofChanged", path, &None),

            Self::ModeChanged { path, .. } => ("ModeChanged", path, &None),

        };

        match hunk {

            Some(hunk) => f

                .debug_struct(name)

                .field("path", path)

                .field("hunk", &(hunk.old.clone(), hunk.new.clone()))

                .finish(),

            _ => f.debug_struct(name).field("path", path).finish(),

        }

    use radicle_surf::diff::{self, DiffFile, Hunk, Line, Modification};

    use crate::git::HunkDiff;

            hunk: Some(Hunk {

            }),

            hunk: Some(Hunk {

            }),

            hunk: Some(Hunk {

                header: Line::from(b"@@ -1,1 +0,0 @@\n".to_vec()),

                lines: vec![Modification::deletion(b"TBD\n".to_vec(), 1)],

                old: 1..2,

                new: 0..0,

            }),

use radicle::cob::{CodeLocation, CodeRange, EntryId, Label, ObjectId, Timestamp, TypedId};

/// Represents the old and new ranges of a unified diff.

pub struct DiffLineRanges {

    old: Range<u32>,

    new: Range<u32>,

}

impl From<&Hunk<Modification>> for DiffLineRanges {

    fn from(hunk: &Hunk<Modification>) -> Self {

        Self {

            old: hunk.old.clone(),

            new: hunk.new.clone(),

        }

    }

}

/// Identifies a line in a unified diff by its old and new line number.

#[derive(Clone, Debug, Default, Hash, Eq, PartialEq)]

pub struct DiffLineIndex {

    old: Option<u32>,

    new: Option<u32>,

}

impl DiffLineIndex {

    pub fn is_start_of(&self, ranges: &DiffLineRanges) -> bool {

        // TODO(erikli): Find out, why comments inserted right before or after

        // the hunk header can have such weird values.

        let old = self

            .old

            .map(|o| self.new.is_none() && o >= 4294967294)

            .unwrap_or_default();

        let new = self

            .new

            .map(|n| n == u32::MAX.saturating_sub(1) || n == ranges.new.end)

            .unwrap_or_default();

        old || new

    }

    pub fn is_end_of(&self, ranges: &DiffLineRanges) -> bool {

        let old = self

            .old

            .map(|o| o == ranges.old.end.saturating_sub(1))

            .unwrap_or_default();

        let new = self

            .new

            .map(|n| n == ranges.new.end.saturating_sub(1))

            .unwrap_or_default();

        old || new

    }

    pub fn is_inside_of(&self, ranges: &DiffLineRanges) -> bool {

        let old = self

            .old

            .map(|o| o >= ranges.old.start && o < ranges.old.end.saturating_sub(1))

            .unwrap_or_default();

        let new = self

            .new

            .map(|n| n >= ranges.new.start && n < ranges.new.end.saturating_sub(1))

            .unwrap_or_default();

        old || new

    }

}

/// Mention hunk header

impl From<&CodeLocation> for DiffLineIndex {

    fn from(location: &CodeLocation) -> Self {

        Self {

            old: location.old.as_ref().map(|r| match r {

                CodeRange::Lines { range } => range.end.saturating_sub(1) as u32,

                CodeRange::Chars { line, range: _ } => line.saturating_sub(1) as u32,

            }),

            new: location.new.as_ref().map(|r| match r {

                CodeRange::Lines { range } => range.end.saturating_sub(1) as u32,

                CodeRange::Chars { line, range: _ } => line.saturating_sub(1) as u32,

            }),

        }

    }

}

/// A type that can map a line index to a line number in a unified diff.

#[derive(Debug)]

pub struct IndexedDiffLines {

    lines: HashMap<DiffLineIndex, u32>,

}

impl IndexedDiffLines {

    pub fn new(diff: &HunkDiff) -> Self {

        let mut indexed = HashMap::new();

        if let Some(hunk) = diff.hunk() {

            for (index, line) in hunk.lines.iter().enumerate() {

                let line_index = match line {

                    Modification::Addition(addition) => DiffLineIndex {

                        old: None,

                        new: Some(addition.line_no),

                    },

                    Modification::Deletion(deletion) => DiffLineIndex {

                        old: Some(deletion.line_no),

                        new: None,

                    },

                    Modification::Context {

                        line: _,

                        line_no_old,

                        line_no_new,

                    } => DiffLineIndex {

                        old: Some(*line_no_old),

                        new: Some(*line_no_new),

                    },

                };

                indexed.insert(line_index, index as u32);

            }

        }

        Self { lines: indexed }

    }

    pub fn line(&self, index: DiffLineIndex) -> Option<u32> {

        self.lines.get(&index).copied()

    }

}

/// All comments per hunk, indexed by their merge location: start, line or end.

    comments: HashMap<MergeLocation, Vec<(EntryId, Comment<CodeLocation>)>>,

    pub fn new(diff: &HunkDiff, comments: Vec<(EntryId, Comment<CodeLocation>)>) -> Self {

        let mut line_comments: HashMap<MergeLocation, Vec<(EntryId, Comment<CodeLocation>)>> =

            HashMap::new();

        let indexed = IndexedDiffLines::new(diff);

            let line = if let Some(location) = comment.1.location() {

                if let Some(hunk) = diff.hunk() {

                    let ranges = DiffLineRanges::from(hunk);

                    let index = DiffLineIndex::from(location);

                    if index.is_start_of(&ranges) {

                        MergeLocation::Start

                    } else if index.is_end_of(&ranges) {

                        MergeLocation::End

                    } else {

                        let mut line = indexed

                            .line(index.clone())

                            .map(|line| MergeLocation::Line(line as usize));

                        // TODO(erikli): Properly fix index lookup rules for addition:

                        // old line number need to be ignored.

                        if line.is_none() {

                            line = indexed

                                .line(DiffLineIndex { old: None, ..index })

                                .map(|line| MergeLocation::Line(line as usize))

                        }

                        line.unwrap_or_default()

                    }

                    MergeLocation::Unknown

                MergeLocation::Unknown

            if let Some(comments) = line_comments.get_mut(&line) {

                line_comments.insert(line, vec![comment.clone()]);

    pub fn all(&self) -> &HashMap<MergeLocation, Vec<(EntryId, Comment<CodeLocation>)>> {

impl From<(&Repository, &Review, &HunkDiff)> for HunkItem<'_> {

    fn from(value: (&Repository, &Review, &HunkDiff)) -> Self {

        let (repo, review, item) = value;

        // - comment code location is inside hunk code range

                        if let Some(hunk) = item.hunk() {

                            let ranges = DiffLineRanges::from(hunk);

                            let index = DiffLineIndex::from(location);

                            log::warn!("Checking comment {comment:?} at {index:?}");

                            return index.is_start_of(&ranges)

                                || index.is_inside_of(&ranges)

                                || index.is_end_of(&ranges);

                let stats = hunk.as_ref().map(HunkStats::from).unwrap_or_default();

                let stats = hunk.as_ref().map(HunkStats::from).unwrap_or_default();

                let stats = hunk.as_ref().map(HunkStats::from).unwrap_or_default();

                    .map(|hunk| Text::from(hunk.to_text(&self.lines)));

    fn diff_line_index_checks_ranges_correctly() -> Result<()> {

        let commit = Oid::from_str("a32c4b93e2573fd83b15ac1ad6bf1317dc8fd760").unwrap();

        let path = PathBuf::from_str("main.rs").unwrap();

        // --------------------------------------------------------------------

        // At the top.

        // --------------------------------------------------------------------

        // @@ -3,8 +3,7 @@

        // 3   3     // or if you prefer to use your keyboard, you can use the "Ctrl + Enter"

        // 4   4     // shortcut.

        // 5   5

        // 6       - // This code is editable, feel free to hack it!

        // 7       - // You can always return to the original code by clicking the "Reset" button ->

        //     6   + // This is still a comment.

        // --------------------------------------------------------------------

        // In the middle.

        // --------------------------------------------------------------------

        // 8   7

        // 9   8     // This is the main function.

        // 10  9     fn main() {

        // ---------------------------------------------------------------------

        // At the end.

        // ---------------------------------------------------------------------

        let diff = test::fixtures::simple_modified_hunk_diff(&path, commit)?;

        let ranges = DiffLineRanges::from(diff.hunk().unwrap());

        let start = CodeLocation {

            commit,

            path: path.clone(),

            old: Some(CodeRange::Lines { range: 3..12 }),

            new: Some(CodeRange::Lines { range: 3..11 }),

        };

        assert!(DiffLineIndex::from(&start).is_start_of(&ranges));

        assert!(!DiffLineIndex::from(&start).is_inside_of(&ranges));

        assert!(!DiffLineIndex::from(&start).is_end_of(&ranges));

        let inside = CodeLocation {

            commit,

            path: path.clone(),

            old: Some(CodeRange::Lines { range: 3..8 }),

            new: Some(CodeRange::Lines { range: 3..7 }),

        };

        assert!(DiffLineIndex::from(&inside).is_inside_of(&ranges));

        assert!(!DiffLineIndex::from(&inside).is_start_of(&ranges));

        assert!(!DiffLineIndex::from(&inside).is_end_of(&ranges));

        let end = CodeLocation {

            commit,

            path: path.clone(),

            old: Some(CodeRange::Lines { range: 3..11 }),

            new: Some(CodeRange::Lines { range: 3..10 }),

        };

        assert!(DiffLineIndex::from(&end).is_end_of(&ranges));

        assert!(!DiffLineIndex::from(&end).is_start_of(&ranges));

        assert!(!DiffLineIndex::from(&end).is_inside_of(&ranges));

        let outside = CodeLocation {

            commit,

            path: path.clone(),

            old: Some(CodeRange::Lines { range: 125..127 }),

            new: Some(CodeRange::Lines { range: 125..128 }),

        };

        assert!(!DiffLineIndex::from(&outside).is_start_of(&ranges));

        assert!(!DiffLineIndex::from(&outside).is_inside_of(&ranges));

        assert!(!DiffLineIndex::from(&outside).is_end_of(&ranges));

        Ok(())

    }

    #[test]

                Some(CodeLocation {

                    path: path.clone(),

                    old: Some(CodeRange::Lines { range: 3..12 }),

                    new: Some(CodeRange::Lines { range: 3..11 }),

                }),

                Some(CodeLocation {

                    path: path.clone(),

                    old: Some(CodeRange::Lines { range: 3..8 }),

                    new: Some(CodeRange::Lines { range: 3..7 }),

                }),

                Some(CodeLocation {

                    path: path.clone(),

                    old: Some(CodeRange::Lines { range: 3..11 }),

                    new: Some(CodeRange::Lines { range: 3..10 }),

                }),

            (top, MergeLocation::Start),

            (end, MergeLocation::End),

                Some(CodeLocation {

                    path: path.clone(),

                    old: Some(CodeRange::Lines { range: 1..18 }),

                    new: Some(CodeRange::Lines { range: 1..17 }),

                }),

                Some(CodeLocation {

                    path: path.clone(),

                    old: Some(CodeRange::Lines { range: 1..4 }),

                    new: None,

                }),