radicle: introduce `cob::common::Title` — heartwood

This patch adds the cob::common::Title struct, this allows instead of using std::str::String or generics and traits for it, to define more precisely what a title should be. It trims the provided string and makes sure it contains no carriage return or new line characters.

Where a std::str::String makes more sense so it’s easier to mutate it, we keep the code as is.

 use anyhow::{anyhow, Context};
 use radicle::cob::identity::{self, IdentityMut, Revision, RevisionId};
 use radicle::cob::Title;
 use radicle::identity::doc::update;
 use radicle::identity::doc::update::EditVisibility;
 use radicle::identity::{doc, Doc, Identity, RawDoc};

 #[derive(Clone, Debug, Default)]
 pub enum Operation {
     Update {
         title: Option<String>,
         title: Option<Title>,
         description: Option<String>,
         delegate: Vec<Did>,
         rescind: Vec<Did>,

     },
     EditRevision {
         revision: Rev,
         title: Option<String>,
         title: Option<Title>,
         description: Option<String>,
     },
     RedactRevision {

         let mut op: Option<OperationName> = None;
         let mut revision: Option<Rev> = None;
         let mut rid: Option<RepoId> = None;
         let mut title: Option<String> = None;
         let mut title: Option<Title> = None;
         let mut description: Option<String> = None;
         let mut delegate: Vec<Did> = Vec::new();
         let mut rescind: Vec<Did> = Vec::new();

                 Long("title")
                     if op == Some(OperationName::Edit) || op == Some(OperationName::Update) =>
                 {
                     title = Some(parser.value()?.to_string_lossy().into());
                     let val = parser.value()?;
                     title = Some(term::args::string(&val).try_into()?);
                 }
                 Long("description")
                     if op == Some(OperationName::Edit) || op == Some(OperationName::Update) =>

     attrs.push([
         term::format::bold("Title").into(),
         term::label(revision.title.to_owned()),
         term::label(revision.title.to_string()),
     ]);
     attrs.push([
         term::format::bold("Revision").into(),

 }
 fn edit_title_description(
     title: Option<String>,
     title: Option<Title>,
     description: Option<String>,
 ) -> anyhow::Result<Option<(String, String)>> {
 ) -> anyhow::Result<Option<(Title, String)>> {
     const HELP: &str = r#"<!--
 Please enter a patch message for your changes. An empty
 message aborts the patch proposal.

     ) -> Self {
         Self {
             category: term::format::dim(category),
             summary: term::Paint::new(summary),
             summary: term::Paint::new(summary.to_string()),
             state,
             name: term::format::tertiary(name),
         }

             };
             (
                 String::from("id"),
                 rev.title.clone(),
                 rev.title.to_string(),
                 term::format::identity::state(&rev.state),
             )
         } else {

 use radicle::cob::common::{Label, Reaction};
 use radicle::cob::issue::{CloseReason, State};
 use radicle::cob::{issue, thread};
 use radicle::cob::{issue, thread, Title};
 use radicle::crypto;
 use radicle::git::Oid;
 use radicle::issue::cache::Issues as _;

         anyhow::bail!("aborting issue creation due to empty title or description");
     };
     let issue = cache.create(
         &title,
         title,
         description,
         labels.as_slice(),
         assignees.as_slice(),

     issues: &'g mut issue::Cache<issue::Issues<'a, R>, cob::cache::StoreWriter>,
     repo: &storage::git::Repository,
     id: Rev,
     title: Option<String>,
     title: Option<Title>,
     description: Option<String>,
     signer: &Device<G>,
 ) -> anyhow::Result<issue::IssueMut<'a, 'g, R, cob::cache::StoreWriter>>

     // Editing via the editor.
     let Some((title, description)) = term::issue::get_title_description(
         Some(title.unwrap_or(issue.title().to_owned())),
         title.and(Title::new(issue.title()).ok()),
         Some(description.unwrap_or(issue.description().to_owned())),
     )?
     else {

 use super::*;
 use radicle::cob;
 use radicle::cob::patch;
 use radicle::cob::{self, Title};
 use radicle::crypto;
 use radicle::node::device::Device;
 use radicle::prelude::*;

     let (title, description) = term::patch::get_edit_message(message, &patch)?;
     match revision_id {
         Some(id) => edit_revision(patch, id, title, description, &signer),
         Some(id) => edit_revision(patch, id, title.to_string(), description, &signer),
         None => edit_root(patch, title, description, &signer),
     }
 }
 fn edit_root<G>(
     mut patch: patch::PatchMut<'_, '_, Repository, cob::cache::StoreWriter>,
     title: String,
     title: Title,
     description: String,
     signer: &Device<G>,
 ) -> anyhow::Result<()>
 where
     G: crypto::signature::Signer<crypto::Signature>,
 {
     let title = if title != patch.title() {
     let title = if title.as_ref() != patch.title() {
         Some(title)
     } else {
         None

 use anyhow::{anyhow, Context as _};
 use radicle::cob;
 use radicle::identity::{Identity, Visibility};
 use radicle::node::Handle as _;
 use radicle::prelude::RepoId;

         doc.visibility = Visibility::Public;
     })?;
     identity.update("Publish repository", "", &doc, &signer)?;
     identity.update(
         cob::Title::new("Publish repository").unwrap(),
         "",
         &doc,
         &signer,
     )?;
     repo.sign_refs(&signer)?;
     repo.set_identity_head()?;
     let validations = repo.validate()?;

 }
 pub fn get_title_description(
     title: Option<String>,
     title: Option<cob::Title>,
     description: Option<String>,
 ) -> io::Result<Option<(String, String)>> {
 ) -> io::Result<Option<(cob::Title, String)>> {
     term::patch::Message::edit_title_description(title, description, OPEN_MSG)
 }

 use thiserror::Error;
 use radicle::cob;
 use radicle::cob::patch;
 use radicle::cob::{self, Title};
 use radicle::git;
 use radicle::patch::{Patch, PatchId};
 use radicle::prelude::Profile;

     /// Open the editor with the given title and description (if any).
     /// Returns the edited title and description, or nothing if it couldn't be parsed.
     pub fn edit_title_description(
         title: Option<String>,
         title: Option<cob::Title>,
         description: Option<String>,
         help: &str,
     ) -> std::io::Result<Option<(String, String)>> {
     ) -> std::io::Result<Option<(Title, String)>> {
         let mut placeholder = String::new();
         if let Some(title) = title {
             placeholder.push_str(title.trim());
             placeholder.push_str(title.as_ref());
             placeholder.push('\n');
         }
         if let Some(description) = description {

             Some((x, y)) => (x, y),
             None => (output.as_str(), ""),
         };
         let (title, description) = (title.trim(), description.trim());
         if title.is_empty() | title.contains('\n') {
         let Ok(title) = Title::new(title) else {
             return Ok(None);
         }
         Ok(Some((title.to_owned(), description.to_owned())))
         };
         Ok(Some((title, description.trim().to_owned())))
     }
     pub fn append(&mut self, arg: &str) {

     repo: &git::raw::Repository,
     base: &git::Oid,
     head: &git::Oid,
 ) -> Result<(String, String), Error> {
 ) -> Result<(Title, String), Error> {
     let display_msg = create_display_message(repo, base, head)?;
     let message = message.get(&display_msg)?;
     let (title, description) = message.split_once('\n').unwrap_or((&message, ""));
     let (title, description) = (title.trim().to_string(), description.trim().to_string());
     if title.is_empty() {
         return Err(io::Error::new(
     let title = Title::new(title.as_str()).map_err(|_| {
         io::Error::new(
             io::ErrorKind::InvalidInput,
             "a patch title must be provided",
         )
         .into());
     }
     })?;
     Ok((title, description))
 }

 pub fn get_edit_message(
     patch_message: term::patch::Message,
     patch: &cob::patch::Patch,
 ) -> io::Result<(String, String)> {
 ) -> io::Result<(Title, String)> {
     let display_msg = edit_display_message(patch.title(), patch.description());
     let patch_message = patch_message.get(&display_msg)?;
     let patch_message = patch_message.replace(PATCH_MSG.trim(), ""); // Delete help message.

 use std::str::FromStr;
 use std::{net, thread, time};
 use radicle::cob;
 use radicle::git;
 use radicle::node;
 use radicle::node::address::Store as _;

     let mut bob_cache = radicle::cob::cache::InMemory::default();
     let issue = bob_issues
         .create(
             "Something's fishy",
             cob::Title::new("Something's fishy").unwrap(),
             "I don't know what it is",
             &[],
             &[],

     }
     /// Create an [`issue::Issue`] in the `NodeHandle`'s storage.
     pub fn issue(&self, rid: RepoId, title: &str, desc: &str) -> cob::ObjectId {
     pub fn issue(&self, rid: RepoId, title: cob::Title, desc: &str) -> cob::ObjectId {
         let repo = self.storage.repository(rid).unwrap();
         let mut issues = issue::Cache::no_cache(&repo).unwrap();
         *issues

     let old_refs = RefsAt::new(&repo, alice.id).unwrap();
     let mut issues = radicle::issue::Cache::no_cache(&repo).unwrap();
     issues
         .create("Issue while offline!", "", &[], &[], [], alice.signer())
         .create(
             cob::Title::new("Issue while offline!").unwrap(),
             "",
             &[],
             &[],
             [],
             alice.signer(),
         )
         .unwrap();
     let new_refs = RefsAt::new(&repo, alice.id).unwrap();
     assert_ne!(old_refs, new_refs);

     log::debug!(target: "test", "Fetch complete with {}", bob.id);
     alice.issue(acme, "Don't fetch self", "Use ^");
     alice.issue(acme, Title::new("Don't fetch self").unwrap(), "Use ^");
     let result = alice.handle.fetch(acme, bob.id, DEFAULT_TIMEOUT).unwrap();
     assert!(result.is_success())
 }

     log::debug!(target: "test", "Fetch complete with {}", bob.id);
     rad::fork_remote(acme, &alice.id, &carol, &bob.storage).unwrap();
     alice.issue(acme, "Missing Remote", "Fixing the missing remote issue");
     alice.issue(
         acme,
         Title::new("Missing Remote").unwrap(),
         "Fixing the missing remote issue",
     );
     let result = bob.handle.fetch(acme, alice.id, DEFAULT_TIMEOUT).unwrap();
     assert!(result.is_success());
     log::debug!(target: "test", "Fetch complete with {}", bob.id);

     log::debug!(target: "test", "Fetch complete with {}", bob.id);
     alice.issue(acme, "Bug", "Bugs, bugs, bugs");
     alice.issue(acme, Title::new("Bug").unwrap(), "Bugs, bugs, bugs");
     let before = alice
         .storage

     // Bob updates his refs.
     bob.issue(
         rid,
         "Updated Sigrefs",
         Title::new("Updated Sigrefs").unwrap(),
         "Updated sigrefs are harshing my vibes",
     );
     // Alice fetches from Bob.

     let issue_id = eve.issue(
         rid,
         "Outdated Sigrefs",
         Title::new("Outdated Sigrefs").unwrap(),
         "Outdated sigrefs are harshing my vibes",
     );
     let repo = eve.storage.repository(rid).unwrap();

     // Fetching from still works despite not having
     // `refs/heads/master`, but has `rad/sigrefs`.
     bob.issue(rid, "Hello, Acme", "Popping in to say hello");
     bob.issue(
         rid,
         Title::new("Hello, Acme").unwrap(),
         "Popping in to say hello",
     );
     alice.handle.fetch(rid, bob.id, DEFAULT_TIMEOUT).unwrap();
     {

                 doc.delegate(bob.signer.public_key().into());
             })
             .unwrap();
         let rev = identity.update("Add Bob", "", &doc, &alice.signer).unwrap();
         let rev = identity
             .update(Title::new("Add Bob").unwrap(), "", &doc, &alice.signer)
             .unwrap();
         repo.set_identity_head_to(rev).unwrap();
         let new = repo.identity_doc().unwrap().doc;

     // Create an issue to ensure there are new refs to fetch
     let issue = bob.issue(
         rid,
         "Delegate Issue",
         Title::new("Delegate Issue").unwrap(),
         "Further investigation into delegates",
     );
     let assert_bobs_issue_exists = |repo: &Repository| {