# *per crate*. If anyone ever wants to set it to a different

# value per crate, this is of course possible. We're waiting

# for the day it makes a difference…

[workspace.dependencies]

amplify = { version = "4.0.0", default-features = false }

        }

    }

        let mut buf = Vec::new();

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

        writer.encode(&self.header)?;

}

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

    let remotes: Vec<_> = repo

        .remotes()?

        .iter()

}

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

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

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

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

        &self,

        name: impl AsRef<RefStr>,

        node: NodeId,

        let remote_url = radicle::git::Url::from(self.rid).with_namespace(node);

        let remote_name = name.as_ref();

}

#[inline]

    let branch = if reference.is_branch() {

        git::raw::Branch::wrap(reference)

    } else {

    }

    #[cfg(feature = "git-ref-format-core")]

        git_ref_format_core::Component::from(self)

    }

}

#[derive(Debug, Error)]

pub enum Update {

    #[error(transparent)]

    Ancestry(#[from] Ancestry),

    /// The [`Signature`]s found in this commit, i.e. the headers corresponding

    /// to `gpgsig`.

        self.headers.signatures()

    }

            .filter_map(move |(k, v)| (k == name).then_some(v))

    }

        self.0.iter().filter_map(|(k, v)| {

            if k == "gpgsig" {

                Signature::from_str(v).ok()

        self.0.get_mut(token)

    }

        self.0.entry(token)

    }

    }

    /// Calls [`std::vec::Drain`].

        self.v.drain(range)

    }

}

        from: &NodeId,

        refs_at: Vec<RefsAt>,

        timeout: time::Duration,

        let from = *from;

        let Some(session) = self.sessions.get_mut(&from) else {

            return Err(TryFetchError::SessionNotConnected);

impl Branch {

    /// Return the branch name to be used for the local branch when creating a

    /// patch.

        match self {

            Self::None => None,

            Self::MirrorUpstream => Some(git::refs::patch(object)),

/// A cursor-like trait to read SSH-encoded things.

pub trait Reader {

    /// Create an SSH reader for `self`.

}

impl Reader for Buffer {

        Cursor {

            s: self,

            position: starting_at,

}

impl Reader for [u8] {

        Cursor {

            s: self,

            position: starting_at,

    pub fn load_mut<R: WriteRepository + cob::Store<Namespace = NodeId>>(

        repo: &R,

        let oid = repo.identity_root()?;

        let oid = ObjectId::from(oid);

            .create(

                cob::Title::new("My first issue").unwrap(),

                "Blah blah blah.",

                &[],

                [],

                &node.signer,

        author: &'a PublicKey,

    ) -> impl DoubleEndedIterator<Item = (RevisionId, &'a Revision)> {

        self.revisions()

    }

    /// List of patch reviews of the given revision.

        revision: RevisionId,

        commit: git::Oid,

        signer: &Device<G>,

    where

        G: crypto::signature::Signer<crypto::Signature>,

    {

        ///

        /// `refs/namespaces/<remote>/refs/rad/id`

        ///

            IDENTITY_BRANCH.with_namespace(remote.into())

        }

        ///

        /// `refs/namespaces/<remote>/refs/rad/root`

        ///

            IDENTITY_ROOT.with_namespace(remote.into())

        }

        ///

        /// `refs/namespaces/<remote>/refs/rad/sigrefs`

        ///

            SIGREFS_BRANCH.with_namespace(remote.into())

        }

/// The `T` can be specified when calling the function. For example, if you

/// wanted to parse the namespace as a `PublicKey`, then you would the function

/// like so, `parse_ref_namespaced::<PublicKey>(s)`.

where

    T: FromStr,

    T::Err: std::error::Error + Send + Sync + 'static,

/// The `T` can be specified when calling the function. For example, if you

/// wanted to parse the namespace as a `PublicKey`, then you would the function

/// like so, `parse_ref::<PublicKey>(s)`.

where

    T: FromStr,

    T::Err: std::error::Error + Send + Sync + 'static,

}

/// Get the repository head.

    let head = repo.head()?.peel_to_commit()?;

    Ok(head)

impl MatchedRule<'_> {

    /// Return the reference name that was used for checking if it was a match.

        &self.refname

    }

pub const MAX_DELEGATES: usize = 255;

/// The current, most recent version of the identity document.

// SAFETY: identity version should never be 0, so we can use `unsafe` here

#[derive(Error, Debug)]

pub enum DocError {

    pub(crate) fn blob_at<R: ReadRepository>(

        commit: Oid,

        repo: &R,

        let path = Path::new("embeds").join(*PATH);

        repo.blob_at(commit, path.as_path()).map_err(DocError::from)

    }

        &self,

        commit: Oid,

        path: P,

    /// Get a blob in this repository, given its id.

    /// Get the head of this repository.

    ///

    /// head using [`ReadRepository::canonical_head`].

    ///

    /// Returns the [`Oid`] as well as the qualified reference name.

    /// Compute the canonical head of this repository.

    ///

    /// Ignores any existing `HEAD` reference.

    ///

    /// Returns the [`Oid`] as well as the qualified reference name.

    /// Get the head of the `rad/id` reference in this repository.

    ///

        &self,

        remote: &RemoteId,

        reference: &Qualified,

    /// Get the [`crate::git::raw::Commit`] found using its `oid`.

    ///

    /// Returns `Err` if the commit did not exist.

    /// Perform a revision walk of a commit history starting from the given head.

    /// Check if the underlying ODB contains the given `oid`.

    fn contains(&self, oid: Oid) -> Result<bool, crate::git::raw::Error>;

    fn references_glob(

        &self,

        pattern: &crate::git::fmt::refspec::PatternStr,

    /// Get repository delegates.

    fn delegates(&self) -> Result<NonEmpty<Did>, RepositoryError> {

        &self,

        commit_id: Oid,

        path: P,

        let commit = self.backend.find_commit(git::raw::Oid::from(commit_id))?;

        let tree = commit.tree()?;

        let entry = tree.get_path(path.as_ref())?;

        Ok(blob)

    }

        self.backend.find_blob(oid.into())

    }

        &self,

        remote: &RemoteId,

        name: &git::fmt::Qualified,

        let name = name.with_namespace(remote.into());

        self.backend.find_reference(&name)

    }

        Ok(oid.into())

    }

        self.backend.find_commit(oid.into())

    }

        let mut revwalk = self.backend.revwalk()?;

        revwalk.push(head.into())?;

    fn references_glob(

        &self,

        pattern: &PatternStr,

        let mut refs = Vec::new();

        for r in self.backend.references_glob(pattern)? {

        Doc::load_at(head, self)

    }

        // If `HEAD` is already set locally, just return that.

        if let Ok(head) = self.backend.head() {

            if let Ok((name, oid)) = git::refs::qualified_from(&head) {

        self.canonical_head()

    }

        let doc = self.identity_doc()?;

        let refname = git::refs::branch(doc.project()?.default_branch());

        let crefs = match doc.canonical_refs()? {

        self.repo.is_empty()

    }

        self.repo.head()

    }

        self.repo.canonical_head()

    }

        self.repo.path()

    }

        self.repo.commit(oid)

    }

        self.repo.revwalk(head)

    }

        &self,

        oid: Oid,

        path: P,

        self.repo.blob_at(oid, path)

    }

        self.repo.blob(oid)

    }

        &self,

        remote: &RemoteId,

        reference: &git::fmt::Qualified,

        self.repo.reference(remote, reference)

    }

    fn references_glob(

        &self,

        pattern: &git::fmt::refspec::PatternStr,

        self.repo.references_glob(pattern)

    }

        SignedRefsAt::load_at(self.at, self.remote, repo)

    }

        &SIGREFS_BRANCH

    }

}

}

/// Populate a repository with commits, branches and blobs.

    assert!(

        scale <= 8,

        "Scale parameter must be less than or equal to 8"

        Ok(self.remotes.is_empty())

    }

        Ok((fmt::qualified!("refs/heads/master"), arbitrary::oid()))

    }

        todo!()

    }

        todo!()

    }

        Err(git::raw::Error::new(

            git::raw::ErrorCode::NotFound,

            git::raw::ErrorClass::None,

        ))

    }

        todo!()

    }

        Ok(true)

    }

        todo!()

    }

        &self,

        _oid: Oid,

        _path: P,

        todo!()

    }

        &self,

        _remote: &RemoteId,

        _reference: &git::fmt::Qualified,

        todo!()

    }

    fn references_glob(

        &self,

        _pattern: &crate::git::fmt::refspec::PatternStr,

        todo!()

    }

        ]

      },

      "locked": {

        "owner": "oxalica",

        "repo": "rust-overlay",

        "type": "github"

      },

      "original": {

          ".md" # testing

          ".adoc" # man pages

          ".json" # testing samples

          "rad-cob-multiset" # testing external COBs

        ]

        ||

        # Default filter from crane (allow .rs files)

      src = lib.cleanSourceWith {

        src = ./.;

[toolchain]

profile = "default"

components = [ "rust-src" ]