radicle: improve inline comments — heartwood

The previous CodeLocation type did not correctly represent the semantics of an inline code location, for the following reasons:

If it is for lines within a file pertaining to the commit, then there should be no old or new ranges, only a single range.
If it is for a patch created by diffing the commit with another commit, then the other commit is missing.

It could be argued that the semantics of these two cases could be retrieved by:

In the first case, just use one of the ranges.
In the second case, infer the commit from the context, e.g. always use Revision::base for locations used in the ReviewComment.

Instead, the type is renamed to PartialLocation to represent these semantics better, and only remains for backwards-compatibility when deserializing existing data.

Two new types are introduced CommitLocation and DiffLocation, which more accurately describe the two cases.

Each of these is used in a Patch’s Revision and Review thread respectively. These are created with new actions RevisionCommitComment and ReviewDiffComment, while deprecating the use of RevisionComment and ReviewComment – they can no longer be constructed outside of the module.

The final part is to ensure that clients can calculate stable diffs for patches – to allow them to display the DiffLocations correctly – the relevant diff options are recorded for each patch. Sane defaults are used if the options are missing.

 ```
 $ rad cob show --repo rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji --type xyz.radicle.patch --object d1f7f869fde9fac19c1779c4c2e77e8361333f91
 {"title":"Start drafting peace treaty","author":{"id":"did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi"},"state":{"status":"open"},"target":"delegates","labels":[],"merges":{},"revisions":{"d1f7f869fde9fac19c1779c4c2e77e8361333f91":{"id":"d1f7f869fde9fac19c1779c4c2e77e8361333f91","author":{"id":"did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi"},"description":[{"author":"z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi","timestamp":1671125284000,"body":"See details.","embeds":[]}],"base":"f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354","oid":"575ed68c716d6aae81ea6b718fd9ac66a8eae532","discussion":{"comments":{},"timeline":[]},"reviews":{},"timestamp":1671125284000,"resolves":[],"reactions":[]}},"assignees":[],"timeline":["d1f7f869fde9fac19c1779c4c2e77e8361333f91"],"reviews":{}}
 {"title":"Start drafting peace treaty","author":{"id":"did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi"},"state":{"status":"open"},"target":"delegates","labels":[],"merges":{},"revisions":{"d1f7f869fde9fac19c1779c4c2e77e8361333f91":{"id":"d1f7f869fde9fac19c1779c4c2e77e8361333f91","author":{"id":"did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi"},"description":[{"author":"z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi","timestamp":1671125284000,"body":"See details.","embeds":[]}],"base":"f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354","oid":"575ed68c716d6aae81ea6b718fd9ac66a8eae532","discussion":{"comments":{},"timeline":[]},"reviews":{},"timestamp":1671125284000,"resolves":[],"reactions":[]}},"assignees":[],"timeline":["d1f7f869fde9fac19c1779c4c2e77e8361333f91"],"reviews":{},"diffOptions":{"algorithm":"Histogram","skipBinary":false,"contextLines":3,"interhunkLines":0,"find":{"exact_match":false,"renames":{"limit":200,"rename_threshold":50}}}}
 ```
 Finally let's update the issue and see the output of `rad cob show` also changes.

 🌱 Fetched from z6Mkux1aUQD2voWWukVb5nNUR7thrHveQG4pDQua8nVhib7Z
 $ rad patch comment 6c61ef1 -m "I think we should use MIT"
 ╭───────────────────────────╮
 │ bob (you) now 833db19     │
 │ bob (you) now f20d3ec     │
 │ I think we should use MIT │
 ╰───────────────────────────╯
 ✓ Synced with 2 seed(s)

 ├────────────────────────────────────────────────────┤
 │ ● opened by alice (you) (717c900) now              │
 ├────────────────────────────────────────────────────┤
 │ bob z6Mkt67…v4N1tRk now 833db19                    │
 │ bob z6Mkt67…v4N1tRk now f20d3ec                    │
 │ I think we should use MIT                          │
 ╰────────────────────────────────────────────────────╯
 $ rad patch comment 6c61ef1 --reply-to 833db19 -m "Thanks, I'll add it!"
 $ rad patch comment 6c61ef1 --reply-to f20d3ec -m "Thanks, I'll add it!"
 ╭─────────────────────────╮
 │ alice (you) now 1803a38 │
 │ alice (you) now 6af0c73 │
 │ Thanks, I'll add it!    │
 ╰─────────────────────────╯
 ✓ Synced with 2 seed(s)

 ``` ~alice (stderr)
 $ git push -f
 ✓ Patch 6c61ef1 updated to revision 93915b9afa94a9dc4f52f12cdf077d4613ea3eb3
 ✓ Patch 6c61ef1 updated to revision f415ddfb8ef2c4e58b73e96cec8303941fe791d2
 To compare against your previous revision 6c61ef1, run:
    git range-diff f2de534[..] 717c900[..] 1cc8cd9[..]

 │ 717c900 Introduce license                                           │
 ├─────────────────────────────────────────────────────────────────────┤
 │ ● opened by alice z6MknSL…StBU8Vi (717c900) now                     │
 │ ↑ updated to 93915b9afa94a9dc4f52f12cdf077d4613ea3eb3 (1cc8cd9) now │
 │ ↑ updated to f415ddfb8ef2c4e58b73e96cec8303941fe791d2 (1cc8cd9) now │
 │   └─ ✓ accepted by bob (you) now                                    │
 ╰─────────────────────────────────────────────────────────────────────╯
 ```

 ```
 $ rad patch comment aa45913 --message 'I cannot wait to get back to the 90s!' --no-announce
 ╭───────────────────────────────────────╮
 │ alice (you) now 686ec1c               │
 │ alice (you) now a6202ea               │
 │ I cannot wait to get back to the 90s! │
 ╰───────────────────────────────────────╯
 $ rad patch comment aa45913 --message 'My favorite decade!' --reply-to 686ec1c -q --no-announce
 f4336e42daf76342f787d574b5ee779d89d05c7a
 $ rad patch comment aa45913 --message 'My favorite decade!' --reply-to a6202ea -q --no-announce
 c13c19202750bd9aa81fffdea2198cedfba7
 ```
 If we realize we made a mistake in the comment, we can go back and edit it:
 ```
 $ rad patch comment aa45913 --edit 686ec1c --message 'I cannot wait to get back to the 80s!' --no-announce
 $ rad patch comment aa45913 --edit a6202ea --message 'I cannot wait to get back to the 80s!' --no-announce
 ╭───────────────────────────────────────╮
 │ alice (you) now 686ec1c               │
 │ alice (you) now a6202ea               │
 │ I cannot wait to get back to the 80s! │
 ╰───────────────────────────────────────╯
 ```

 And if we really made a mistake, then we can redact the comment entirely:
 ```
 $ rad patch comment aa45913 --redact f4336e4 --no-announce
 ✓ Redacted comment f4336e42daf76342f787d574b5ee779d89d05c7a
 $ rad patch comment aa45913 --redact 9063c13c19202750bd9aa81fffdea2198cedfba7 --no-announce
 ✓ Redacted comment 9063c13c19202750bd9aa81fffdea2198cedfba7
 ```
 Now, let's checkout the patch that we just created:

 ```
 $ rad patch comment e4934b6d9dbe01ce3c7fbb5b77a80d5f1dacdc46 --message 'I cannot wait to get back to the 90s!' -q
 c66f87afadc7c7c857f8bb92973c25f64e75776
 a8598c5f6ad9f4aa3acd701a61a380b0d275
 ✓ Synced with 1 seed(s)
 ```

 ```
 ``` (stderr)
 $ git push rad -o no-sync -o patch.message="Use markdown for requirements"
 ✓ Patch e4934b6 updated to revision 9d62420e779e5cfe1dc02c51eddec9a0907aa844
 ✓ Patch e4934b6 updated to revision 9e458d00b2e9a26993113c48259781725e2cbee3
 To compare against your previous revision 773b9aa, run:
    git range-diff f2de534[..] 27857ec[..] f567f69[..]

 Great, all fixed up, lets accept and merge the code.
 ```
 $ rad patch review e4934b6 --revision 9d62420 --accept
 $ rad patch review e4934b6 --revision 9e458d00b2e9a26993113c48259781725e2cbee3 --accept
 ✓ Patch e4934b6 accepted
 ✓ Synced with 1 seed(s)
 $ git checkout master

 ```
 ``` (stderr)
 $ git push rad master
 ✓ Patch e4934b6d9dbe01ce3c7fbb5b77a80d5f1dacdc46 merged at revision 9d62420
 ✓ Patch e4934b6d9dbe01ce3c7fbb5b77a80d5f1dacdc46 merged at revision 9e458d0
 ✓ Canonical reference refs/heads/master updated to target commit f567f695d25b4e8fb63b5f5ad2a584529826e908
 ✓ Synced with 1 seed(s)
 To rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji/z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

 ├─────────────────────────────────────────────────────────────────────┤
 │ ● opened by bob z6Mkt67…v4N1tRk (3e674d1) now                       │
 │ ↑ updated to 773b9aab58b11e9fa83d0ed0baca2bea6ff889c9 (27857ec) now │
 │ * revised by alice (you) in 9d62420 (f567f69) now                   │
 │ * revised by alice (you) in 9e458d0 (f567f69) now                   │
 │   └─ ✓ accepted by alice (you) now                                  │
 │   └─ ✓ merged by alice (you) at revision 9d62420 (f567f69) now      │
 │   └─ ✓ merged by alice (you) at revision 9e458d0 (f567f69) now      │
 ╰─────────────────────────────────────────────────────────────────────╯
 ```

 //!
 use std::collections::VecDeque;
 use std::fmt::Write as _;
 use std::ops::{Deref, Not, Range};
 use std::ops::{Deref, Range};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::{fmt, io};
 use radicle::cob;
 use radicle::cob::patch::{PatchId, Revision, Verdict};
 use radicle::cob::{CodeLocation, CodeRange};
 use radicle::cob::{CodeRange, DiffLocation, HunkIndex};
 use radicle::crypto;
 use radicle::git;
 use radicle::node::device::Device;
 use radicle::prelude::*;
 use radicle::storage::git::{cob::DraftStore, Repository};
 use radicle_git_ext::Oid;
 use radicle_surf::diff::*;
 use radicle_surf::diff;
 use radicle_surf::diff::{
     Copied, Diff, DiffContent, DiffFile, EofNewLine, FileDiff, Hunks, Modification, Moved,
 };
 use radicle_term::{Element, VStack};
 use crate::git::pretty_diff::ToPretty;

     }
 }
 /// Keep track of the [`diff::Hunk`] and its `index` within the diff patch.
 #[derive(Debug)]
 pub struct Hunk {
     /// Index of the hunk within its respective patch.
     index: usize,
     /// The [`diff::Hunk`] that is being kept track of.
     inner: diff::Hunk<Modification>,
 }
 impl Hunk {
     pub fn new(index: usize, hunk: diff::Hunk<Modification>) -> Self {
         Self { index, inner: hunk }
     }
     pub fn as_index(&self, range: Option<Range<usize>>) -> Option<HunkIndex> {
         range.map(|range| HunkIndex::new(self.index, CodeRange::lines(range)))
     }
 }
 impl TryFrom<&Hunk> for HunkHeader {
     type Error = unified_diff::Error;
     fn try_from(Hunk { ref inner, .. }: &Hunk) -> Result<Self, Self::Error> {
         Self::try_from(inner)
     }
 }
 /// A single review item. Can be a hunk or eg. a file move.
 /// Files are usually split into multiple review items.
 #[derive(Debug)]

         path: PathBuf,
         header: FileHeader,
         new: DiffFile,
         hunk: Option<Hunk<Modification>>,
         hunk: Option<Hunk>,
     },
     FileDeleted {
         path: PathBuf,
         header: FileHeader,
         old: DiffFile,
         hunk: Option<Hunk<Modification>>,
         hunk: Option<Hunk>,
     },
     FileModified {
         path: PathBuf,
         header: FileHeader,
         old: DiffFile,
         new: DiffFile,
         hunk: Option<Hunk<Modification>>,
         hunk: Option<Hunk>,
     },
     FileMoved {
         moved: Moved,

 }
 impl ReviewItem {
     fn hunk(&self) -> Option<&Hunk<Modification>> {
     fn hunk(&self) -> Option<&Hunk> {
         match self {
             Self::FileAdded { hunk, .. } => hunk.as_ref(),
             Self::FileDeleted { hunk, .. } => hunk.as_ref(),

                     .child(header);
                 if let Some(hunk) = hunk {
                     let hunk = hunk.pretty(&mut hi, &highlighted, repo);
                     let hunk = hunk.inner.pretty(&mut hi, &highlighted, repo);
                     if !hunk.is_empty() {
                         return vstack.divider().merge(hunk).boxed();
                     }

                         ..
                     } = a.diff
                     {
                         hs.pop()
                         hs.len()
                             .checked_sub(1)
                             .and_then(|i| hs.pop().map(|h| Hunk::new(i, h)))
                     } else {
                         None
                     },

                         eof,
                         ..
                     } => {
                         for hunk in hunks {
                         for (i, hunk) in hunks.iter().enumerate() {
                             self.add_item(ReviewItem::FileModified {
                                 path: m.path.clone(),
                                 header: header.clone(),
                                 old: m.old.clone(),
                                 new: m.new.clone(),
                                 hunk: Some(hunk),
                                 hunk: Some(Hunk::new(i, hunk.clone())),
                             });
                         }
                         if let EofNewLine::OldMissing | EofNewLine::NewMissing = eof {

             header.old_line_no -= self.delta as u32;
             header.new_line_no -= self.delta as u32;
             let h = Hunk {
             let h = h.inner.clone();
             let h = diff::Hunk {
                 header: header.to_unified_string()?.as_bytes().to_owned().into(),
                 lines: h.lines.clone(),
                 old: h.old.clone(),
                 new: h.new.clone(),
                 lines: h.lines,
                 old: h.old,
                 new: h.new,
             };
             writer.encode(&h)?;
         }

                     let path = old.or(new);
                     if let (Some(hunk), Some((path, _))) = (item.hunk(), path) {
                         let builder = CommentBuilder::new(revision.head(), path.to_path_buf());
                         let builder = CommentBuilder::new(
                             *revision.base(),
                             revision.head(),
                             path.to_path_buf(),
                         );
                         let comments = builder.edit(hunk)?;
                         patch.transaction("Review comments", signer, |tx| {

 #[derive(Debug, PartialEq, Eq)]
 struct ReviewComment {
     location: CodeLocation,
     location: DiffLocation,
     body: String,
 }

 #[derive(Debug)]
 struct CommentBuilder {
     base: Oid,
     commit: Oid,
     path: PathBuf,
     comments: Vec<ReviewComment>,
 }
 impl CommentBuilder {
     fn new(commit: Oid, path: PathBuf) -> Self {
     fn new(base: Oid, commit: Oid, path: PathBuf) -> Self {
         Self {
             base,
             commit,
             path,
             comments: Vec::new(),
         }
     }
     fn edit(mut self, hunk: &Hunk<Modification>) -> Result<Vec<ReviewComment>, Error> {
     fn edit(mut self, hunk: &Hunk) -> Result<Vec<ReviewComment>, Error> {
         let mut input = String::new();
         for line in hunk.to_unified_string()?.lines() {
         for line in hunk.inner.to_unified_string()?.lines() {
             writeln!(&mut input, "> {line}")?;
         }
         let output = term::Editor::comment()

             .edit()?;
         if let Some(output) = output {
             let header = HunkHeader::try_from(hunk)?;
             self.add_hunk(header, &output);
             self.add_hunk(hunk, &output);
         }
         Ok(self.comments())
     }
     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);
     fn add_hunk(&mut self, hunk: &Hunk, input: &str) -> &mut Self {
         let lines = input
             .trim()
             .lines()
             .map(|l| l.trim())
             // Skip the hunk header
             .filter(|l| !l.starts_with("> @@"));
         let mut comment = String::new();
         // Keeps track of the line index within the hunk itself
         let mut line_ix = 0_usize;
         // Keeps track of whether the first comment is at the top-level
         let mut top_level = true;
         for line in lines {
             if line.starts_with('>') {
                 if !comment.is_empty() {
                     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;
                     if top_level {
                         // Top-level comment
                         self.add_comment(hunk.as_index(None), &comment);
                     } else {
                         self.add_comment(
                             hunk.as_index(Some(line_ix.saturating_sub(1)..line_ix)),
                             &comment,
                         );
                     }
                     comment.clear();
                 }
                 line_ix += 1;
                 // Can no longer be a top-level comment
                 top_level = false;
             } else {
                 comment.push_str(line);
                 comment.push('\n');

         }
         if !comment.is_empty() {
             self.add_comment(
                 &hunk,
                 hunk.as_index(Some(line_ix.saturating_sub(1)..line_ix)),
                 &comment,
                 old_start..old_line - 1,
                 new_start..new_line - 1,
             );
         }
         self
     }
     fn add_comment(
         &mut self,
         hunk: &HunkHeader,
         comment: &str,
         mut old_range: Range<usize>,
         mut new_range: Range<usize>,
     ) {
     fn add_comment(&mut self, selection: Option<HunkIndex>, comment: &str) {
         // Empty lines between quoted text can generate empty comments
         // that should be filtered out.
         if comment.trim().is_empty() {
             return;
         }
         // 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 });
         self.comments.push(ReviewComment {
             location: CodeLocation {
                 commit: self.commit,
             location: DiffLocation {
                 base: self.base,
                 head: self.commit,
                 path: self.path.clone(),
                 old: old_range,
                 new: new_range,
                 selection,
             },
             body: comment.trim().to_owned(),
         });

 "#;
         let base = git::raw::Oid::zero().into();
         let commit = Oid::from_str("a32c4b93e2573fd83b15ac1ad6bf1317dc8fd760").unwrap();
         let path = PathBuf::from_str("main.rs").unwrap();
         let expected = &[
             (ReviewComment {
                 location: CodeLocation {
                 location: DiffLocation::hunk_level(
                     base,
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 2559..2565 }),
                     new: Some(CodeRange::Lines { range: 2560..2563 }),
                 },
                     path.clone(),
                     HunkIndex::new(0, CodeRange::lines(5..6)),
                 ),
                 body: "Comment #1.".to_owned(),
             }),
             (ReviewComment {
                 location: CodeLocation {
                 location: DiffLocation::hunk_level(
                     base,
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 2565..2568 }),
                     new: Some(CodeRange::Lines { range: 2563..2567 }),
                 },
                     path.clone(),
                     HunkIndex::new(0, CodeRange::lines(11..12)),
                 ),
                 body: "Comment #2.".to_owned(),
             }),
             (ReviewComment {
                 location: CodeLocation {
                 location: DiffLocation::hunk_level(
                     base,
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 2568..2571 }),
                     new: Some(CodeRange::Lines { range: 2567..2570 }),
                 },
                     path.clone(),
                     HunkIndex::new(0, CodeRange::lines(16..17)),
                 ),
                 body: "Comment #3.".to_owned(),
             }),
             (ReviewComment {
                 location: CodeLocation {
                 location: DiffLocation::hunk_level(
                     base,
                     commit,
                     path: path.clone(),
                     old: None,
                     new: Some(CodeRange::Lines { range: 2570..2571 }),
                 },
                     path.clone(),
                     HunkIndex::new(0, CodeRange::lines(17..18)),
                 ),
                 body: "Comment #4.".to_owned(),
             }),
             (ReviewComment {
                 location: CodeLocation {
                 location: DiffLocation::hunk_level(
                     base,
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 2571..2577 }),
                     new: Some(CodeRange::Lines { range: 2571..2578 }),
                 },
                     path.clone(),
                     HunkIndex::new(0, CodeRange::lines(25..26)),
                 ),
                 body: "Comment #5.".to_owned(),
             }),
         ];
         let mut builder = CommentBuilder::new(commit, path.clone());
         let mut builder = CommentBuilder::new(base, commit, path.clone());
         builder.add_hunk(
             HunkHeader {
                 old_line_no: 2559,
                 old_size: 18,
                 new_line_no: 2560,
                 new_size: 18,
                 text: vec![],
             },
             &Hunk::new(
 ,
                 diff::Hunk {
                     header: diff::Line::from(vec![]),
                     lines: std::iter::repeat(diff::Modification::addition(
                         diff::Line::from(vec![]),
 ,
                     ))
                     .take(26)
                     .collect(),
                     old: 2559..2578,
                     new: 2560..2579,
                 },
             ),
             input,
         );
         let actual = builder.comments();

             patch::MergeTarget::default(),
             base,
             head,
             None,
             &[],
             signer,
         )

 use std::fmt;
 use std::fmt::Display;
 use std::hash::Hash;
 use std::ops::{Deref, Range};
 use std::path::PathBuf;
 use std::str::FromStr;

     }
 }
 /// **Note**: this type is deprecated and should no longer be used.
 /// Use [`DiffLocation`] instead.
 ///
 /// Describes a code location that can be used for comments on
 /// patches, issues, and diffs.
 ///
 /// It is called a `PartialLocation`, because it describes a potential diff
 /// compared to its `commit`, but does not describe the other `Oid` – thus the
 /// other `Oid` must be inferred from context.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CodeLocation {
 pub struct PartialLocation {
     /// [`Oid`] of the Git commit.
     pub commit: Oid,
     pub(crate) commit: Oid,
     /// Path of file.
     pub path: PathBuf,
     pub(crate) path: PathBuf,
     /// Line range on old file. `None` for added files.
     pub old: Option<CodeRange>,
     pub(crate) old: Option<CodeRange>,
     /// Line range on new file. `None` for deleted files.
     pub new: Option<CodeRange>,
     pub(crate) new: Option<CodeRange>,
 }
 /// Code range.
 /// The specified range that selects a section of code.
 ///
 /// When used with [`HunkIndex`], the range represents the lines within the hunk
 /// itself, which are 0-indexed.
 ///
 /// Note: `CodeRange` is an `enum` that has the single variant `Lines`, but may
 /// add more cases in the future.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase", tag = "type")]
 pub enum CodeRange {
     /// One or more lines.
     Lines { range: Range<usize> },
     /// Character range within a line.
     Chars { line: usize, range: Range<usize> },
 }
 impl std::cmp::PartialOrd for CodeRange {
 impl PartialOrd for CodeRange {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         Some(self.cmp(other))
     }
 }
 impl std::cmp::Ord for CodeRange {
 impl Ord for CodeRange {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         match (self, other) {
             (CodeRange::Lines { .. }, CodeRange::Chars { .. }) => std::cmp::Ordering::Less,
             (CodeRange::Chars { .. }, CodeRange::Lines { .. }) => std::cmp::Ordering::Greater,
             (CodeRange::Lines { range: a }, CodeRange::Lines { range: b }) => {
                 a.clone().cmp(b.clone())
             (CodeRange::Lines { range: x }, CodeRange::Lines { range: y }) => {
                 x.start.cmp(&y.start).then(x.end.cmp(&y.end))
             }
             (
                 CodeRange::Chars {
                     line: l1,
                     range: r1,
                 },
                 CodeRange::Chars {
                     line: l2,
                     range: r2,
                 },
             ) => l1.cmp(l2).then(r1.clone().cmp(r2.clone())),
         }
     }
 }
 impl CodeRange {
     /// Get the starting position of the range.
     ///
     /// If the range is [`CodeRange::Lines`], this corresponds to the start of
     /// the line range.
     pub fn line_start(&self) -> usize {
         match self {
             CodeRange::Lines { range } => range.start,
         }
     }
     /// Get the ending position of the range.
     ///
     /// If the range is [`CodeRange::Lines`], this corresponds to the end of
     /// the line range.
     pub fn line_end(&self) -> usize {
         match self {
             CodeRange::Lines { range } => range.end,
         }
     }
     /// Construct a `CodeRange` for which is one or more lines.
     pub fn lines(range: Range<usize>) -> Self {
         Self::Lines { range }
     }
 }
 /// Describes a selection within a diff.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct DiffLocation {
     /// The old side of the commit diff.
     pub base: Oid,
     /// The new side of the commit diff.
     pub head: Oid,
     /// Path of the file.
     pub path: PathBuf,
     /// The selected section of the diff patch.
     /// If the selection is `None`, then this is a file-level comment.
     pub selection: Option<HunkIndex>,
 }
 impl DiffLocation {
     /// Construct a file-level diff location, where the
     /// [`DiffLocation::selection`] is `None`.
     pub fn file_level(base: Oid, head: Oid, path: PathBuf) -> Self {
         Self {
             base,
             head,
             path,
             selection: None,
         }
     }
     /// Construct a hunk-level diff location, where the
     /// [`DiffLocation::selection`] is set to the given `hunk`.
     pub fn hunk_level(base: Oid, head: Oid, path: PathBuf, hunk: HunkIndex) -> Self {
         Self {
             base,
             head,
             path,
             selection: Some(hunk),
         }
     }
     /// Get the [`DiffLocation::selection`].
     pub fn selection(&self) -> Option<&HunkIndex> {
         self.selection.as_ref()
     }
     /// Get the index for the hunk of the [`DiffLocation::selection`].
     pub fn hunk_index(&self) -> Option<usize> {
         self.selection().map(|s| s.index())
     }
     /// Get the [`CodeRange`] of the [`DiffLocation::selection`].
     pub fn code_range(&self) -> Option<&CodeRange> {
         self.selection().map(|s| s.range())
     }
 }
 /// The combined index of the hunk and range within that hunk.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct HunkIndex {
     /// The index of the hunk in the patch.
     hunk: usize,
     /// The line selection within the hunk itself.
     range: CodeRange,
 }
 impl HunkIndex {
     pub fn new(hunk: usize, range: CodeRange) -> Self {
         Self { hunk, range }
     }
     pub fn index(&self) -> usize {
         self.hunk
     }
     pub fn range(&self) -> &CodeRange {
         &self.range
     }
 }
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod test {

 pub mod cache;
 pub mod diff;
 mod actions;
 pub use actions::ReviewEdit;
 pub use actions::{ReviewComment, ReviewEdit};
 mod encoding;

 use thiserror::Error;
 use crate::cob;
 use crate::cob::common::{Author, Authorization, CodeLocation, Label, Reaction, Timestamp};
 use crate::cob::common::{Author, Authorization, DiffLocation, Label, Reaction, Timestamp};
 use crate::cob::store::Transaction;
 use crate::cob::store::{Cob, CobAction};
 use crate::cob::thread;

     },
     #[serde(rename = "review.redact")]
     ReviewRedact { review: ReviewId },
     #[serde(rename = "review.comment")]
     ReviewComment {
         review: ReviewId,
         body: String,
         #[serde(default, skip_serializing_if = "Option::is_none")]
         location: Option<CodeLocation>,
         /// Comment this is a reply to.
         /// Should be [`None`] if it's the first comment.
         /// Should be [`Some`] otherwise.
         #[serde(default, skip_serializing_if = "Option::is_none")]
         reply_to: Option<CommentId>,
         /// Embeded content.
         #[serde(default, skip_serializing_if = "Vec::is_empty")]
         embeds: Vec<Embed<Uri>>,
     },
     #[serde(rename = "review.comment.edit")]
     ReviewCommentEdit {
         review: ReviewId,

         /// Review comments resolved by this revision.
         #[serde(default, skip_serializing_if = "BTreeSet::is_empty")]
         resolves: BTreeSet<(EntryId, CommentId)>,
         /// The diff options for the patch.
         ///
         /// **N.B**: Only relevant for the initial revision creation.
         #[serde(default, skip_serializing_if = "Option::is_none")]
         diff_options: Option<diff::Options>,
     },
     #[serde(rename = "revision.edit")]
     RevisionEdit {

         #[serde(default, skip_serializing_if = "Vec::is_empty")]
         embeds: Vec<Embed<Uri>>,
     },
     /// React to the revision.
     #[serde(rename = "revision.react")]
     RevisionReact {
         revision: RevisionId,
         #[serde(default, skip_serializing_if = "Option::is_none")]
         location: Option<CodeLocation>,
         reaction: Reaction,
         active: bool,
     },
     #[serde(rename = "revision.redact")]
     RevisionRedact { revision: RevisionId },
     #[serde(rename_all = "camelCase")]
     #[serde(rename = "revision.comment")]
     RevisionComment {
         /// The revision to comment on.
         revision: RevisionId,
         /// For comments on the revision code.
         #[serde(default, skip_serializing_if = "Option::is_none")]
         location: Option<CodeLocation>,
         /// Comment body.
         body: String,
         /// Comment this is a reply to.
         /// Should be [`None`] if it's the top-level comment.
         /// Should be the root [`CommentId`] if it's a top-level comment.
         #[serde(default, skip_serializing_if = "Option::is_none")]
         reply_to: Option<CommentId>,
         /// Embeded content.
         #[serde(default, skip_serializing_if = "Vec::is_empty")]
         embeds: Vec<Embed<Uri>>,
     },
     /// Edit a revision comment.
     #[serde(rename = "revision.comment.edit")]
     RevisionCommentEdit {

         reaction: Reaction,
         active: bool,
     },
     /// Edit a review's summary, verdict, labels, and embeds.
     // Note that the tags live on `actions::ReviewEdit`, and according to the
     // serde.rs docs, it must come after the other variants due to the
     // `untagged` declaration.
     /// Edit a review's summary, verdict, labels, and embeds.
     #[serde(untagged)]
     ReviewEdit(actions::ReviewEdit),
     /// Publish a comment to a review.
     #[serde(untagged)]
     ReviewComment(actions::ReviewComment),
     /// Publish a comment to a revision.
     #[serde(untagged)]
     RevisionComment(actions::RevisionComment),
     /// React to the revision.
     #[serde(untagged)]
     RevisionReact(actions::RevisionReact),
 }
 impl From<actions::ReviewComment> for Action {
     fn from(value: actions::ReviewComment) -> Self {
         Action::ReviewComment(value)
     }
 }
 impl From<actions::RevisionComment> for Action {
     fn from(value: actions::RevisionComment) -> Self {
         Action::RevisionComment(value)
     }
 }
 impl From<actions::RevisionReact> for Action {
     fn from(value: actions::RevisionReact) -> Self {
         Action::RevisionReact(value)
     }
 }
 impl CobAction for Action {