[[package]]

name = "base64"

version = "0.21.7"

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

checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"

[[package]]

name = "git-ref-format"

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

dependencies = [

 "git-ref-format-core",

 "git-ref-format-macro",

[[package]]

name = "git-ref-format-core"

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

dependencies = [

 "bstr",

 "serde",

[[package]]

name = "git-ref-format-macro"

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

dependencies = [

 "git-ref-format-core",

 "quote",

 "syn 2.0.89",

]

[[package]]

name = "nonempty"

version = "0.9.0"

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

checksum = "995defdca0a589acfdd1bd2e8e3b896b4d4f7675a31fd14c32611440c7f608e6"

]

[[package]]

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

dependencies = [

 "proc-macro2",

 "quote",

]

[[package]]

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

dependencies = [

 "proc-macro2",

 "quote",

]

[[package]]

 "localtime",

 "log",

 "multibase",

 "pretty_assertions",

 "qcheck",

 "qcheck-macros",

 "radicle-cob",

 "radicle-crypto",

 "radicle-ssh",

 "schemars",

 "serde",

 "chrono",

 "clap",

 "dunce",

 "human-panic",

 "itertools",

 "lexopt",

 "localtime",

 "log",

 "pretty_assertions",

 "radicle",

 "radicle-cli-test",

 "radicle-cob",

 "radicle-crypto",

 "radicle-node",

 "radicle-surf",

 "radicle-term",

version = "0.17.0"

dependencies = [

 "fastrand",

 "git2",

 "log",

 "qcheck",

 "qcheck-macros",

 "radicle-crypto",

 "radicle-dag",

 "serde",

 "serde_json",

 "signature 2.2.0",

 "gix-protocol",

 "gix-transport",

 "log",

 "radicle",

 "thiserror 1.0.69",

]

[[package]]

name = "radicle-git-ext"

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

dependencies = [

 "git-ref-format",

 "git2",

 "localtime",

 "log",

 "netservices",

 "qcheck",

 "qcheck-macros",

 "radicle",

 "radicle-crypto",

 "radicle-fetch",

 "radicle-protocol",

 "radicle-signals",

 "radicle-systemd",

 "fastrand",

 "localtime",

 "log",

 "paste",

 "qcheck",

 "qcheck-macros",

 "radicle",

 "radicle-crypto",

 "radicle-fetch",

 "scrypt",

 "serde",

 "serde_json",

 "radicle",

 "radicle-cli",

 "radicle-crypto",

 "thiserror 1.0.69",

]

[[package]]

name = "radicle-std-ext"

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

[[package]]

name = "radicle-surf"

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

dependencies = [

 "anyhow",

 "flate2",

 "git2",

 "log",

 "radicle-git-ext",

 "radicle-std-ext",

 "tar",

cyphernet = "0.5.2"

dunce = "1.0.5"

fastrand = { version = "2.0.0", default-features = false }

git2 = { version = "0.19.0", default-features = false }

human-panic = "2"

itertools = "0.14"

radicle-crypto = { version = "0.14", path = "crates/radicle-crypto" }

radicle-dag = { version = "0.10", path = "crates/radicle-dag" }

radicle-fetch = { version = "0.16", path = "crates/radicle-fetch" }

radicle-git-ref-format = { version = "0.1.0", path = "crates/radicle-git-ref-format", default-features = false }

radicle-node = { version = "0.16", path = "crates/radicle-node" }

radicle-oid = { version = "0.1.0", path = "crates/radicle-oid", default-features = false }

winpipe = "0.1.1"

zeroize = "1.5.7"

[workspace.lints]

clippy.type_complexity = "allow"

clippy.enum_variant_names = "allow"

chrono = { workspace = true, features = ["clock", "std"] }

clap = { version = "4.5.44", features = ["derive"] }

dunce = { workspace = true }

human-panic.workspace = true

itertools.workspace = true

lexopt = { workspace = true }

radicle = { workspace = true, features = ["logger", "schemars"] }

radicle-cob = { workspace = true }

radicle-crypto = { workspace = true }

radicle-term = { workspace = true }

schemars = { workspace = true }

serde = { workspace = true }

pub fn setup_remote(

    setup: &project::SetupRemote,

    remote_id: &NodeId,

    aliases: &impl AliasStore,

    let remote_name = if let Some(name) = remote_name {

        name

    } else {

        } else {

            remote_id.to_human()

        };

            .map_err(|_| anyhow!("invalid remote name: '{name}'"))?

    };

    let (remote, branch) = setup.run(&remote_name, *remote_id)?;

use anyhow::anyhow;

use radicle::rad;

use radicle_surf as surf;

        })

        .collect::<Result<Vec<_>, _>>()?;

    opts.patience(true)

        .minimal(true)

        .context_lines(options.unified as u32);

    find_opts.exact_match_only(true);

    find_opts.all(true);

use anyhow::anyhow;

use localtime::LocalTime;

use radicle::cob::TypedId;

use radicle::identity::Identity;

use radicle::issue::cache::Issues as _;

use radicle::node::notifications;

use radicle::node::notifications::*;

use radicle::patch::cache::Patches as _;

use radicle::prelude::{NodeId, Profile, RepoId};

use radicle::{cob, git, Storage};

use term::Element as _;

use radicle::crypto::ssh;

use radicle::explorer::ExplorerUrl;

use radicle::git::raw;

use radicle::identity::project::ProjectName;

use radicle::identity::{Doc, RepoId, Visibility};

use radicle::node::events::UploadPack;

    let path = options.path.as_deref().unwrap_or(cwd.as_path());

    let repo = match git::Repository::open(path) {

        Ok(r) => r,

            anyhow::bail!("a Git repository was not found at the given path")

        }

        Err(e) => return Err(e.into()),

use radicle::cob::patch::PatchId;

use radicle::cob::{patch, Label, Reaction};

use radicle::patch::cache::Patches as _;

use radicle::storage::git::transport;

use radicle::{prelude::*, Node};

use anyhow::anyhow;

use radicle::cob::patch;

use radicle::cob::patch::RevisionId;

use radicle::patch::cache::Patches as _;

use radicle::patch::PatchId;

use radicle::storage::git::Repository;

            Some(refname) => Ok(Qualified::from_refstr(refname)

                .map_or_else(|| refname.clone(), |q| q.to_ref_string())),

            // SAFETY: Patch IDs are valid refstrings.

                .join(RefString::try_from(term::format::cob(id).item).unwrap())),

        }

    }

    patch_id: &PatchId,

    revision_id: Option<RevisionId>,

    stored: &Repository,

    profile: &Profile,

    opts: Options,

) -> anyhow::Result<()> {

    let mut spinner = term::spinner("Performing checkout...");

    let patch_branch = opts.branch(patch_id)?;

            }

    if opts.force {

        let mut builder = radicle::git::raw::build::CheckoutBuilder::new();

fn find_patch_commit<'a>(

    revision: &patch::Revision,

    stored: &Repository,

    match working.find_commit(head) {

        Ok(commit) => Ok(commit),

            let output = git::process::fetch_pack(

                Some(working.path()),

                stored,

use radicle::cob::patch::{PatchId, RevisionId, Verdict};

use radicle::git;

use radicle::prelude::*;

use radicle::storage::git::Repository;

            hunk,

        } if by_hunk => {

            crate::warning::obsolete("rad patch review --patch");

            opts.patience(true)

                .minimal(true)

                .context_lines(unified as u32);

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

use radicle::crypto;

use radicle::git;

use radicle::node::device::Device;

use radicle::prelude::*;

use radicle::storage::git::{cob::DraftStore, Repository};

use radicle_surf::diff::*;

use radicle_term::{Element, VStack};

    fn paths(&self) -> (Option<(&Path, Oid)>, Option<(&Path, Oid)>) {

        match self {

            Self::FileMoved { moved } => (

            ),

            Self::FileCopied { copied } => (

            ),

        }

    }

        }

    }

        let mut buf = Vec::new();

        let mut writer = unified_diff::Writer::new(&mut buf);

        writer.encode(&self.header)?;

        }

        drop(writer);

    }

}

/// of changes introduced by a patch.

pub struct Brain<'a> {

    /// Where the review draft is being stored.

    /// The commit pointed to by the ref.

    /// The tree of accepted changes pointed to by the head commit.

}

impl<'a> Brain<'a> {

    fn new(

        patch: PatchId,

        remote: &NodeId,

        let refname = Self::refname(&patch, remote);

        let author = repo.signature()?;

        let oid = repo.commit(

    fn load(

        patch: PatchId,

        remote: &NodeId,

        // TODO: Validate this leads to correct UX for potentially abandoned drafts on

        // past revisions.

        let refname = Self::refname(&patch, remote);

    }

    /// Accept changes to the brain.

        let mut index = repo.apply_to_tree(&self.accepted, &diff, None)?;

        let accepted = index.write_tree_to(repo)?;

        self.accepted = repo.find_tree(accepted)?;

    }

    /// Get the brain's refname given the patch and remote.

        git::refs::storage::draft::review(remote, patch)

    }

}

    pub fn run<G>(

        self,

        revision: &Revision,

        signer: &Device<G>,

    ) -> anyhow::Result<()>

    where

    fn diff(

        &self,

    ) -> Result<Diff, Error> {

        find_opts.exact_match_only(true);

        find_opts.all(true);

        find_opts.copies(false); // We don't support finding copies at the moment.

    #[error(transparent)]

    Format(#[from] std::fmt::Error),

    #[error(transparent)]

}

#[derive(Debug)]

use std::process;

use radicle::cob::patch;

use radicle::storage::git::Repository;

use crate::terminal as term;

    verbose: bool,

    profile: &Profile,

    stored: &Repository,

) -> anyhow::Result<()> {

    let patches = term::cob::patches(profile, stored)?;

    let Some(patch) = patches.get(patch_id).map_err(|e| Error::WithHint {

use radicle::cob::patch;

use radicle::prelude::*;

use radicle::storage::git::Repository;

use crate::terminal as term;

use crate::terminal::patch::*;

/// Run patch update.

pub fn run(

    patch_id: patch::PatchId,

    message: term::patch::Message,

    profile: &Profile,

    repository: &Repository,

) -> anyhow::Result<()> {

    // `HEAD`; This is what we are proposing as a patch.

    let head_branch = try_branch(workdir.head()?)?;

    let head_oid = branch_oid(&head_branch)?;

    let base_oid = match base_id {

        Some(oid) => oid,

    };

    // N.b. we don't update if both the head and base are the same as

    // any previous revision

    if patch

        .revisions()

    {

        return Ok(());

    }

    let (_, revision) = patch.latest();

    let message = term::patch::get_update_message(message, workdir, revision, &head_oid)?;

    let signer = term::signer(profile)?;

    term::print(revision);

use anyhow::anyhow;

use radicle::prelude::NodeId;

use radicle::storage::ReadStorage;

use std::str::FromStr;

use radicle::prelude::*;

use radicle::Profile;

use radicle_crypto::PublicKey;

    name: Option<RefString>,

    tracking: Option<BranchName>,

    profile: &Profile,

    fetch: bool,

    sync: bool,

) -> anyhow::Result<()> {

            let remote = remote?;

            let sigrefs = repo.reference_oid(&remote, &git::refs::storage::SIGREFS_BRANCH)?;

            let mut walk = repo.raw().revwalk()?;

            stats.local.pushes += walk.count();

            stats.local.forks += 1;

use anyhow::{anyhow, Context as _};

use radicle::git;

use radicle::prelude::{NodeId, RepoId};

use radicle::storage::{ReadRepository, ReadStorage};

pub struct Options {

    rid: Option<RepoId>,

    target: Option<git::Oid>,

    nid: Option<NodeId>,

    interval: time::Duration,

        let mut rid = None;

        let mut nid: Option<NodeId> = None;

        let mut target: Option<git::Oid> = None;

        let mut interval: Option<time::Duration> = None;

        let mut timeout: time::Duration = time::Duration::MAX;

            thread::sleep(options.interval);

            let oid = reference(&repo, &nid, &qualified)?;

            if oid != initial {

                break;

            }

            if now.elapsed()? >= options.timeout {

fn reference<R: ReadRepository>(

    repo: &R,

    nid: &NodeId,

    match repo.reference_oid(nid, qual) {

        Ok(oid) => Ok(Some(oid)),

        Err(e) => Err(e),

    }

}

use radicle::crypto::ssh;

use radicle::git;

use radicle::git::{Version, VERSION_REQUIRED};

use radicle::prelude::{NodeId, RepoId};

use radicle::storage::git::transport;

pub use radicle::git::raw::{

    build::CheckoutBuilder, AnnotatedCommit, Commit, Direction, ErrorCode, MergeAnalysis,

};

pub const CONFIG_COMMIT_GPG_SIGN: &str = "commit.gpgsign";

        &self.0

    }

    where

    {

        let object = repo.revparse_single(self.as_str())?;

        Ok(object.id().into())

    pub url: radicle::git::Url,

    pub pushurl: Option<radicle::git::Url>,

}

    type Error = RemoteError;

        let url = value.url().map_or(Err(RemoteError::MissingUrl), |url| {

            Ok(radicle::git::Url::from_str(url)?)

        })?;

}

impl<'a> Deref for Remote<'a> {

    fn deref(&self) -> &Self::Target {

        &self.inner

}

/// Return the list of radicle remotes for the given repository.

    let remotes: Vec<_> = repo

        .remotes()?

        .iter()

}

/// Check if the git remote is configured for the `Repository`.

    match repo.find_remote(alias) {

        Ok(_) => Ok(true),

        Err(err) => Err(err.into()),

    }

}

/// Get the repository's "rad" remote.

    match radicle::rad::remote(repo) {

        Ok((remote, id)) => Ok((remote, id)),

        Err(radicle::rad::RemoteError::NotFound(_)) => Err(anyhow!(

}

pub fn add_tag(

    message: &str,

    patch_tag_name: &str,

    let head = repo.head()?;

    let oid = repo.tag(patch_tag_name, &commit, &repo.signature()?, message, false)?;

    Ok(oid)

use std::path::{Path, PathBuf};

use radicle::git;

use radicle_surf::diff;

use radicle_surf::diff::{Added, Copied, Deleted, FileStats, Hunks, Modified, Moved};

use radicle_surf::diff::{Diff, DiffContent, FileDiff, Hunk, Modification};

/// A repository of Git blobs.

pub trait Repo {

    /// Lookup a blob from the repo.

    /// Lookup a file in the workdir.

    fn file(&self, path: &Path) -> Option<Blob>;

}

        if blob.is_binary() {

            Ok(Blob::Binary)

        repo: &R,

    ) -> Self::Output {

        let old = None;

        pretty_modification(header, &self.diff, old, new, repo, hi)

    }

        header: &Self::Context,

        repo: &R,

    ) -> Self::Output {

        let new = None;

        pretty_modification(header, &self.diff, old, new, repo, hi)

        header: &Self::Context,

        repo: &R,

    ) -> Self::Output {

        pretty_modification(header, &self.diff, old, new, repo, hi)

    }

use radicle_surf::diff::FileStats;

use thiserror::Error;

use radicle::git::raw::Oid;

use radicle_surf::diff;

use radicle_surf::diff::{Diff, DiffContent, DiffFile, FileDiff, Hunk, Hunks, Line, Modification};

        r.read_to_string(&mut s)?;

            .map_err(|e| Error::syntax(format!("decoding unified diff: {e}")))?;

        let d =

            Diff::try_from(d).map_err(|e| Error::syntax(format!("decoding unified diff: {e}")))?;

                if old.mode == new.mode {

                    w.meta(format!(

                        "index {}..{} {:o}",

                        u32::from(old.mode.clone()),

                    ))?;

                } else {

                    w.meta(format!("new mode {:o}", u32::from(new.mode.clone())))?;

                    w.meta(format!(

                        "index {}..{}",

                    ))?;

                }

                w.meta(format!(

                    "index {}..{}",

                    term::format::oid(Oid::zero()),

                ))?;

                w.meta("--- /dev/null")?;

                ))?;

                w.meta(format!(

                    "index {}..{}",

                    term::format::oid(Oid::zero())

                ))?;

use radicle::prelude::*;

use crate::git;

use radicle::node::NodeId;

/// Setup a repository remote and tracking branch.

use radicle::cob::{self, issue, patch};

use radicle::crypto;

use radicle::node::{Address, Alias};

use radicle::prelude::{Did, NodeId, RepoId};

use radicle::cob::patch;

use radicle::cob::Title;

use radicle::git;

use radicle::patch::{Patch, PatchId};

use radicle::prelude::Profile;

use radicle::storage::git::Repository;

    #[error(transparent)]

    Fmt(#[from] fmt::Error),

    #[error("git: {0}")]

    #[error("i/o error: {0}")]

    Io(#[from] io::Error),

    #[error("invalid utf-8 string")]

}

/// Create a helpful default `Patch` message out of one or more commit messages.

    let mut commits = commits.into_iter().rev();

    let count = commits.len();

    let Some(commit) = commits.next() else {

/// Return commits between the merge base and a head.

pub fn patch_commits<'a>(

    base: &git::Oid,

    head: &git::Oid,

    let mut commits = Vec::new();

    let mut revwalk = repo.revwalk()?;

    revwalk.push_range(&format!("{base}..{head}"))?;

/// The message shown in the editor when creating a `Patch`.

fn create_display_message(

    base: &git::Oid,

    head: &git::Oid,

) -> Result<String, Error> {

/// The user can bail out if an empty title is entered.

pub fn get_create_message(

    message: term::patch::Message,

    base: &git::Oid,

    head: &git::Oid,

) -> Result<(Title, String), Error> {

/// The message shown in the editor when updating a `Patch`.

fn update_display_message(

) -> Result<String, Error> {

        return Ok(REVISION_MSG.trim_start().to_string());

    }

/// Get a patch update message.

pub fn get_update_message(

    message: term::patch::Message,

    latest: &patch::Revision,

    head: &git::Oid,

) -> Result<String, Error> {

}

/// List the given commits in a table.

    commits

        .iter()

        .map(|commit| {

/// Print commits ahead and behind.

pub fn print_commits_ahead_behind(

) -> anyhow::Result<()> {

    let (ahead, behind) = repo.graph_ahead_behind(left, right)?;

    id: &PatchId,

    verbose: bool,

    stored: &Repository,

    profile: &Profile,

) -> anyhow::Result<()> {

    let (_, revision) = patch.latest();

    } else {

        vec![]

    };

    let author = patch.author();

    let author = term::format::Author::new(author.id(), profile, verbose);

    let labels = patch.labels().map(|l| l.to_string()).collect::<Vec<_>>();

#[cfg(test)]

mod test {

    use super::*;

    use radicle::test::fixtures;

    use std::path;

    fn commit(

        parent: &git::Oid,

        msg: &str,

    ) -> git::Oid {

            "anonymous",

            "anonymous@radicle.example.com",

        )

        .unwrap();

        let tree =

            git::write_tree(path::Path::new("README"), "Hello World!\n".as_bytes(), repo).unwrap();

    fn test_create_display_message() {

        let tmpdir = tempfile::tempdir().unwrap();

        let (repo, commit_0) = fixtures::repository(&tmpdir);

        let commit_1 = commit(

            &repo,

            &refname!("feature"),

    fn test_update_display_message() {

        let tmpdir = tempfile::tempdir().unwrap();

        let (repo, commit_0) = fixtures::repository(&tmpdir);

        let commit_1 = commit(&repo, &refname!("feature"), &commit_0, "commit 1\n");

        let commit_2 = commit(&repo, &refname!("feature"), &commit_1, "commit 2\n");

use anyhow::anyhow;

use radicle::git;

use radicle::prelude::*;

use radicle::storage::git::Repository;

use crate::terminal as term;

/// Give the oid of the branch or an appropriate error.

#[inline]

    let oid = branch

        .get()

        .target()

}

#[inline]

    let (_, _, head, tail) = git_ref.non_empty_components();

    std::iter::once(head).chain(tail).collect()

}

/// as well as your own (eg. `rad/master`).

pub fn get_merge_target(

    storage: &Repository,

    let (qualified_ref, target_oid) = storage.canonical_head()?;

    let head_oid = branch_oid(head_branch)?;

        anyhow::bail!("commits are already included in the target branch; nothing to do");

    }

}

/// Get the diff stats between two commits.

/// Should match the default output of `git diff <old> <new> --stat` exactly.

pub fn diff_stats(

    old: &Oid,

    new: &Oid,

    let old_tree = old.tree()?;

    let new_tree = new.tree()?;

    let mut diff = repo.diff_tree_to_tree(Some(&old_tree), Some(&new_tree), None)?;

    diff.find_similar(Some(&mut find_opts))?;

    diff.stats()

/// Create a human friendly message about git's sync status.

pub fn ahead_behind(

    revision_oid: Oid,

    head_oid: Oid,

) -> anyhow::Result<term::Line> {

    if a == 0 && b == 0 {

        return Ok(term::Line::new(term::format::dim("up to date")));

    }

}

/// Get the branches that point to a commit.

    let mut branches: Vec<String> = vec![];

    for r in repo.references()?.flatten() {

            continue;

        }

        if let (Some(oid), Some(name)) = (&r.target(), &r.shorthand()) {

                branches.push(name.to_string());

            };

        };

}

#[inline]

    let branch = if reference.is_branch() {

    } else {

        anyhow::bail!("cannot create patch from detached head; aborting")

    };

default = []

# Only used for testing. Ensures that commit ids are stable.

stable-commit-ids = []

[dependencies]

fastrand = { workspace = true }

log = { workspace = true }

nonempty = { workspace = true, features = ["serialize"] }

radicle-crypto = { workspace = true, features = ["ssh"] }

radicle-dag = { workspace = true }

serde = { workspace = true, features = ["derive"] }

serde_json = { workspace = true }

signature = { workspace = true }

qcheck = { workspace = true }

qcheck-macros = { workspace = true }

radicle-crypto = { workspace = true, features = ["test", "git-ref-format-core"] }

tempfile = { workspace = true }

// Copyright © 2022 The Radicle Link Contributors

pub mod git;

// Copyright © 2022 The Radicle Team

/// Environment variable to set to overwrite the commit date for both the author and the committer.

///

use std::path::PathBuf;

use std::sync::LazyLock;

use nonempty::NonEmpty;

use crate::change::store::Version;

use crate::signatures;

    trailers, Embed,

};

/// Name of the COB manifest file.

pub const MANIFEST_BLOB_NAME: &str = "manifest";

/// Path under which COB embeds are kept.

    use std::str::Utf8Error;

    use std::string::FromUtf8Error;

    use thiserror::Error;

    use crate::signatures::error::Signatures;

    #[derive(Debug, Error)]

    pub enum Create {

        #[error(transparent)]

        #[error(transparent)]

        FromUtf8(#[from] FromUtf8Error),

        #[error(transparent)]

    #[derive(Debug, Error)]

    pub enum Load {

        #[error(transparent)]

        #[error(transparent)]

        Signatures(#[from] Signatures),

        #[error(transparent)]

        let (id, timestamp) = write_commit(

            self,

            // Commit to tips, extra parents and resource.

            tips.iter()

                .cloned()

            signature.clone(),

            related

                .iter()

            tree,

        )?;

    fn parents_of(&self, id: &Oid) -> Result<Vec<Oid>, Self::LoadError> {

        Ok(self

            .parent_ids()

            .map(Oid::from)

            .collect::<Vec<_>>())

    }

    fn manifest_of(&self, id: &Oid) -> Result<crate::Manifest, Self::LoadError> {

        let tree = commit.tree()?;

        load_manifest(self, &tree)

    }

    fn load(&self, id: Self::ObjectId) -> Result<Entry, Self::LoadError> {

        let trailers = parse_trailers(commit.trailers())?;

        let (resources, related): (Vec<_>, Vec<_>) = trailers.iter().partition(|t| match t {

            CommitTrailer::Resource(_) => true,

            CommitTrailer::Related(_) => false,

        });

        let parents = commit

            .parents()

            .map(Oid::from)

            .filter(|p| !resources.contains(p) && !related.contains(p))

            .collect();

            .into_iter()

            .collect::<Vec<_>>();

        let Some((key, sig)) = signatures.pop() else {

) -> Result<(Oid, Timestamp), error::Create> {

    let trailers: Vec<OwnedTrailer> = trailers

        .into_iter()

        .collect();

    let author = repo.signature()?;

    #[allow(unused_variables)]

            .map_err(signatures::error::Signatures::from)?

            .as_str(),

    );

    #[cfg(feature = "stable-commit-ids")]

    // Ensures the commit id doesn't change on every run.

    let (author, timestamp) = {

        (

            Author {

                ..author

            },

            stable,

        )

    };

        let Ok(timestamp) = s.trim().parse::<i64>() else {

            panic!(

                "Invalid timestamp value {s:?} for `{}`",

            );

        };

        let author = Author {

            ..author

        };

        (author, timestamp)

            let oid = embed.content;

            let path = PathBuf::from(embed.name);