Files
heartwood/radicle-cob/src/object.rs
T
Fintan Halpenny 8508eab8fa radicle: update radicle-git-ext
This change updates to the latest radicle-git-ext, which required a
few changes within the radicle family of crates.

One set of changes is that the radicle-git-ext crate subsumes
git-commit, git-trailers, and git-ref-format -- so all those imports
go through radicle-git-ext.

The commit code requires that parent `Oid`s point to commits, which
made some tests fail. One of the reasons for these failures is that
the patch tests used fabricated `Oid`s and so the verification would
fail. This is fixed by allowing the test context code to create
`PatchRequest`s that create valid commits.
The other reason for failure was that the identity `Action` passed an
`Oid` that pointed to a blob. This is fixed by removing that code and
making a note of it in documentation.

The final major change was moving the Refspec type into git-ref-format
and removing the AsRefspecs trait. The trait was not required and
could its usage could be replaced by simpler code.

Signed-off-by: Fintan Halpenny <fintan.halpenny@gmail.com>
X-Clacks-Overhead: GNU Terry Pratchett
2023-05-08 10:36:15 +01:00

104 lines
2.4 KiB
Rust

// Copyright © 2022 The Radicle Link Contributors
use std::{convert::TryFrom as _, fmt, ops::Deref, str::FromStr};
use git_ext::ref_format::{Component, RefString};
use git_ext::Oid;
use serde::{Deserialize, Serialize};
use thiserror::Error;
pub mod collaboration;
pub use collaboration::{
create, get, info, list, parse_refstr, remove, update, CollaborativeObject, Create, Update,
Updated,
};
pub mod storage;
pub use storage::{Commit, Objects, Reference, Storage};
#[derive(Debug, Error)]
pub enum ParseObjectId {
#[error(transparent)]
Git(#[from] git2::Error),
}
/// The id of an object
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ObjectId(Oid);
impl FromStr for ObjectId {
type Err = ParseObjectId;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let oid = Oid::from_str(s)?;
Ok(ObjectId(oid))
}
}
impl From<Oid> for ObjectId {
fn from(oid: Oid) -> Self {
ObjectId(oid)
}
}
impl From<&Oid> for ObjectId {
fn from(oid: &Oid) -> Self {
(*oid).into()
}
}
impl From<git2::Oid> for ObjectId {
fn from(oid: git2::Oid) -> Self {
Oid::from(oid).into()
}
}
impl From<&git2::Oid> for ObjectId {
fn from(oid: &git2::Oid) -> Self {
ObjectId(Oid::from(*oid))
}
}
impl Deref for ObjectId {
type Target = Oid;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl fmt::Display for ObjectId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl Serialize for ObjectId {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_bytes(self.0.as_bytes())
}
}
impl<'de> Deserialize<'de> for ObjectId {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let raw = <&[u8]>::deserialize(deserializer)?;
let oid = Oid::try_from(raw).map_err(serde::de::Error::custom)?;
Ok(ObjectId(oid))
}
}
impl From<&ObjectId> for Component<'_> {
fn from(id: &ObjectId) -> Self {
let refstr = RefString::try_from(id.0.to_string())
.expect("collaborative object id's are valid ref strings");
Component::from_refstr(refstr)
.expect("collaborative object id's are valid refname components")
}
}