"rand_core 0.6.4",

 "rand_core 0.6.4",

 "rand_core 0.6.4",

 "rand_core 0.6.4",

name = "fnv"

version = "1.0.7"

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

checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

[[package]]

 "rand_core 0.6.4",

 "rand 0.8.5",

 "rand_core 0.6.4",

name = "proptest"

version = "1.9.0"

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

checksum = "bee689443a2bd0a16ab0348b52ee43e3b2d1b1f931c8aa5c9f8de4c86fbe8c40"

dependencies = [

 "bit-set",

 "bit-vec",

 "bitflags 2.9.1",

 "num-traits",

 "rand 0.9.2",

 "rand_chacha 0.9.0",

 "rand_xorshift",

 "regex-syntax 0.8.5",

 "rusty-fork",

 "tempfile",

 "unarray",

]

[[package]]

 "rand 0.8.5",

name = "quick-error"

version = "1.2.3"

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

checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"

[[package]]

 "radicle-core",

name = "radicle-core"

version = "0.1.0"

dependencies = [

 "git2",

 "gix-hash",

 "multibase",

 "proptest",

 "qcheck",

 "radicle-crypto",

 "radicle-git-ref-format",

 "radicle-oid",

 "schemars",

 "serde",

 "serde_json",

 "sqlite",

 "thiserror 2.0.17",

]

[[package]]

 "rand_chacha 0.3.1",

 "rand_core 0.6.4",

]

[[package]]

name = "rand"

version = "0.9.2"

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

checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"

dependencies = [

 "rand_chacha 0.9.0",

 "rand_core 0.9.3",

 "rand_core 0.6.4",

]

[[package]]

name = "rand_chacha"

version = "0.9.0"

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

checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"

dependencies = [

 "ppv-lite86",

 "rand_core 0.9.3",

name = "rand_core"

version = "0.9.3"

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

checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"

dependencies = [

 "getrandom 0.3.3",

]

[[package]]

name = "rand_xorshift"

version = "0.4.0"

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

checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"

dependencies = [

 "rand_core 0.9.3",

]

[[package]]

 "rand_core 0.6.4",

name = "rusty-fork"

version = "0.3.1"

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

checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2"

dependencies = [

 "fnv",

 "quick-error",

 "tempfile",

 "wait-timeout",

]

[[package]]

 "rand_core 0.6.4",

 "rand_core 0.6.4",

name = "unarray"

version = "0.1.4"

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

checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"

[[package]]

name = "wait-timeout"

version = "0.2.1"

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

checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"

dependencies = [

 "libc",

]

[[package]]

 "rand 0.8.5",

proptest = "1.9"

radicle-core = { version = "0.1", path = "crates/radicle-core" }

thiserror = { version = "2", default-features = false }

thiserror = { workspace = true, default-features = true }

thiserror = { workspace = true, default-features = true }

thiserror = { workspace = true, default-features = true }

[package]

name = "radicle-core"

description = "Radicle core data type definitions"

homepage.workspace = true

repository.workspace = true

version = "0.1.0"

edition.workspace = true

license.workspace = true

keywords = ["radicle", "git", "data types"]

rust-version.workspace = true

# For documentation of features refer to the module documentation in `./lib.rs`

[features]

default = ["std"]

git2 = ["dep:git2", "radicle-oid/git2"]

gix = ["dep:gix-hash", "radicle-oid/gix"]

std = ["radicle-oid/std", "thiserror/std", "schemars/std", "serde/std"]

[dependencies]

git2 = { workspace = true, optional = true }

gix-hash = { workspace = true, optional = true }

multibase = { workspace = true }

proptest = { workspace = true, optional = true }

qcheck = { workspace = true, optional = true }

radicle-crypto = { workspace = true }

radicle-git-ref-format = { workspace = true, optional = true }

radicle-oid = { workspace = true, default-features = false, features = ["sha1"] }

schemars = { workspace = true, optional = true, default-features = false, features = ["derive"] }

serde = { workspace = true, optional = true, default-features = false }

sqlite = { workspace = true, optional = true }

thiserror = { workspace = true, default-features = false }

[dev-dependencies]

proptest = { workspace = true }

serde_json = { workspace = true }

[lints]

workspace = true

#![no_std]

//! This a crate for defining core data type for the Radicle protocol, such as

//! [`RepoId`].

//!

//! # Feature Flags

//!

//! The only default feature is `std`.

//!

//! ## `std`

//!

//! [`OsString`]: ::doc_std::ffi::OsString

//!

//! Provides implementation of [`TryFrom<OsString>`].

//!

//! Enabled by default, since it is expected that most dependents will use the

//! standard library.

//!

//! ## `git2`

//!

//! [`git2::Oid`]: ::git2::Oid

//!

//! Provides conversion from a [`git2::Oid`] to a [`RepoId`].

//!

//! ## `gix`

//!

//! [`ObjectId`]: ::gix_hash::ObjectId

//!

//! Provides conversion from a [`ObjectId`] to a [`RepoId`].

//!

//! ## `radicle-git-ref-format`

//!

//! Provides conversions from data types defined in `radicle-core` into valid

//! reference components and/or strings.

//!

//! ## `serde`

//!

//! [`Serialize`]: ::serde::ser::Serialize

//! [`Deserialize`]: ::serde::de::Deserialize

//!

//! Provides implementations of [`Serialize`] and [`Deserialize`].

//!

//! ## `schemars`

//!

//! [`JsonSchema`]: ::schemars::JsonSchema

//!

//! Provides implementations of [`JsonSchema`].

//!

//! ## `proptest`

//!

//! [`proptest::Strategy`]: ::proptest::strategy::Strategy

//!

//! Provides functions for generating different types of [`proptest::Strategy`].

//!

//! ## `qcheck`

//!

//! [`qcheck::Arbitrary`]: ::qcheck::Arbitrary

//!

//! Provides implementations of [`qcheck::Arbitrary`].

//!

//! ## `sqlite`

//!

//! [`sqlite::BindableWithIndex`]: ::sqlite::BindableWithIndex

//! [`sqlite::Value`]: ::sqlite::Value

//!

//! Provides implementations of [`sqlite::BindableWithIndex`] and `TryFrom`

//! implementations from the [`sqlite::Value`] type to the domain type.

#[cfg(doc)]

extern crate std as doc_std;

extern crate alloc;

pub mod node;

pub use node::NodeId;

pub mod repo;

pub use repo::RepoId;

//! A Radicle node on the network is identified by its [`NodeId`], which in turn

//! is a Ed25519 public key.

//!

//! The human-readable format is a multibase-encoded format of the underlying Ed25519 public key, i.e.

//! ```

//! MULTIBASE(base58-btc, MULTICODEC(public-key-type, raw-public-key-bytes))

//! ```

//! which results in strings that look like:

//! ```

//! z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

//! ```

use radicle_crypto::PublicKey;

/// Public identifier of a node device in the network.

///

/// # Legacy

///

/// This is a type alias, providing little protection around evolving a [`NodeId`]

/// and having it very tightly coupled with a [`PublicKey`].

///

/// Future iterations will change this to provide a better API for working with

/// [`NodeId`]'s and their usage in the protocol.

pub type NodeId = PublicKey;

use alloc::string::String;

use alloc::string::ToString as _;

use alloc::vec::Vec;

use radicle_oid::Oid;

use thiserror::Error;

/// Radicle identifier prefix.

pub const RAD_PREFIX: &str = "rad:";

#[derive(Error, Debug)]

pub enum IdError {

    #[error(transparent)]

    Multibase(#[from] multibase::Error),

    #[error("invalid length: expected {expected} bytes, got {actual} bytes")]

    Length { expected: usize, actual: usize },

}

/// A repository identifier.

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]

#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]

pub struct RepoId(

    #[cfg_attr(feature = "schemars", schemars(

        with = "String",

        description = "A repository identifier. Starts with \"rad:\", followed by a multibase Base58 encoded Git object identifier.",

        regex(pattern = r"rad:z[1-9a-km-zA-HJ-NP-Z]+"),

        length(min = 5),

        example = &"rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5",

    ))]

    Oid,

);

impl core::fmt::Display for RepoId {

    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

        f.write_str(self.urn().as_str())

    }

}

impl core::fmt::Debug for RepoId {

    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

        write!(f, "RepoId({self})")

    }

}

impl RepoId {

    /// Format the identifier as a human-readable URN.

    ///

    /// Eg. `rad:z3XncAdkZjeK9mQS5Sdc4qhw98BUX`.

    ///

    pub fn urn(&self) -> String {

        RAD_PREFIX.to_string() + &self.canonical()

    }

    /// Parse an identifier from the human-readable URN format.

    /// Accepts strings without the radicle prefix as well,

    /// for convenience.

    pub fn from_urn(s: &str) -> Result<Self, IdError> {

        let s = s.strip_prefix(RAD_PREFIX).unwrap_or(s);

        let id = Self::from_canonical(s)?;

        Ok(id)

    }

    /// Format the identifier as a multibase string.

    ///

    /// Eg. `z3XncAdkZjeK9mQS5Sdc4qhw98BUX`.

    ///

    pub fn canonical(&self) -> String {

        multibase::encode(multibase::Base::Base58Btc, AsRef::<[u8]>::as_ref(&self.0))

    }

    pub fn from_canonical(input: &str) -> Result<Self, IdError> {

        const EXPECTED_LEN: usize = 20;

        let (_, bytes) = multibase::decode(input)?;

        let bytes: [u8; EXPECTED_LEN] =

            bytes.try_into().map_err(|bytes: Vec<u8>| IdError::Length {

                expected: EXPECTED_LEN,

                actual: bytes.len(),

            })?;

        Ok(Self(Oid::from_sha1(bytes)))

    }

}

impl core::str::FromStr for RepoId {

    type Err = IdError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {

        Self::from_urn(s)

    }

}

#[cfg(feature = "std")]

mod std_impls {

    extern crate std;

    use super::{IdError, RepoId};

    use std::ffi::OsString;

    impl TryFrom<OsString> for RepoId {

        type Error = IdError;

        fn try_from(value: OsString) -> Result<Self, Self::Error> {

            let string = value.to_string_lossy();

            Self::from_canonical(&string)

        }

    }

    impl std::hash::Hash for RepoId {

        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

            self.0.hash(state)

        }

    }

}

impl From<Oid> for RepoId {

    fn from(oid: Oid) -> Self {

        Self(oid)

    }

}

impl core::ops::Deref for RepoId {

    type Target = Oid;

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

        &self.0

    }

}

#[cfg(feature = "git2")]

mod git2_impls {

    use super::RepoId;

    impl From<git2::Oid> for RepoId {

        fn from(oid: git2::Oid) -> Self {

            Self(oid.into())

        }

    }

}

#[cfg(feature = "gix")]

mod gix_impls {

    use super::RepoId;

    impl From<gix_hash::ObjectId> for RepoId {

        fn from(oid: gix_hash::ObjectId) -> Self {

            Self(oid.into())

        }

    }

}

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

mod radicle_git_ref_format_impls {

    use alloc::string::ToString;

    use radicle_git_ref_format::{Component, RefString};

    use super::RepoId;

    impl From<&RepoId> for Component<'_> {

        fn from(id: &RepoId) -> Self {

            let refstr = RefString::try_from(id.0.to_string())

                .expect("repository id's are valid ref strings");

            Component::from_refstr(refstr).expect("repository id's are valid refname components")

        }

    }

}

#[cfg(feature = "serde")]

mod serde_impls {

    use alloc::string::String;

    use serde::{de, Deserialize, Deserializer, Serialize};

    use super::RepoId;

    impl Serialize for RepoId {

        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

        where

            S: serde::Serializer,

        {

            serializer.collect_str(&self.urn())

        }

    }

    impl<'de> Deserialize<'de> for RepoId {

        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

        where

            D: Deserializer<'de>,

        {

            String::deserialize(deserializer)?

                .parse()

                .map_err(de::Error::custom)

        }

    }

    #[cfg(test)]

    mod test {

        use proptest::proptest;

        use super::super::*;

        fn prop_roundtrip_serde_json(rid: RepoId) {

            let encoded = serde_json::to_string(&rid).unwrap();

            let decoded = serde_json::from_str(&encoded).unwrap();

            assert_eq!(rid, decoded);

        }

        proptest! {

            #[test]

            fn assert_prop_roundtrip_serde_json(rid in arbitrary::rid()) {

                prop_roundtrip_serde_json(rid)

            }

        }

    }

}

#[cfg(feature = "sqlite")]

mod sqlite_impls {

    use alloc::format;

    use alloc::string::ToString;

    use super::RepoId;

    use sqlite::{BindableWithIndex, Error, ParameterIndex, Statement, Value};

    impl TryFrom<&Value> for RepoId {

        type Error = Error;

        fn try_from(value: &Value) -> Result<Self, Self::Error> {

            match value {

                Value::String(id) => RepoId::from_urn(id).map_err(|e| Error {

                    code: None,

                    message: Some(e.to_string()),

                }),

                _ => Err(Error {

                    code: None,

                    message: Some(format!("sql: invalid type `{:?}` for id", value.kind())),

                }),

            }

        }

    }

    impl BindableWithIndex for &RepoId {

        fn bind<I: ParameterIndex>(self, stmt: &mut Statement<'_>, i: I) -> sqlite::Result<()> {

            self.urn().as_str().bind(stmt, i)

        }

    }

}

#[cfg(any(test, feature = "proptest"))]

pub mod arbitrary {

    use proptest::prelude::Strategy;

    use super::RepoId;

    pub fn rid() -> impl Strategy<Value = RepoId> {

        proptest::array::uniform20(proptest::num::u8::ANY)

            .prop_map(|bytes| RepoId::from(radicle_oid::Oid::from_sha1(bytes)))

    }

}

#[cfg(feature = "qcheck")]

impl qcheck::Arbitrary for RepoId {

    fn arbitrary(g: &mut qcheck::Gen) -> Self {

        let bytes = <[u8; 20]>::arbitrary(g);

        let oid = radicle_oid::Oid::from_sha1(bytes);

        RepoId::from(oid)

    }

}

#[cfg(test)]

#[allow(clippy::unwrap_used)]

mod test {

    use super::*;

    use proptest::proptest;

    fn prop_roundtrip_parse(rid: RepoId) {

        use core::str::FromStr as _;

        let encoded = rid.to_string();

        let decoded = RepoId::from_str(&encoded).unwrap();

        assert_eq!(rid, decoded);

    }

    proptest! {

        #[test]

        fn assert_prop_roundtrip_parse(rid in arbitrary::rid()) {

            prop_roundtrip_parse(rid)

        }

    }

}

thiserror = { workspace = true, default-features = true }

thiserror = { workspace = true, default-features = true }

thiserror = { workspace = true, default-features = true }

thiserror = { workspace = true, default-features = true }

thiserror = { workspace = true, default-features = true }

thiserror = { workspace = true, default-features = true }

thiserror = { workspace = true, default-features = true }

thiserror = { workspace = true, default-features = true }

qcheck = [

  "radicle-core/qcheck",

  "dep:qcheck"

]

schemars = [

  "radicle-oid/schemars",

  "radicle-core/schemars",

  "radicle-localtime/schemars",

  "dep:schemars"

]

radicle-core = { workspace = true, features = ["git2", "serde", "sqlite"] }

thiserror = { workspace = true, default-features = true }

pub use radicle_core::repo::*;

pub use radicle_core::NodeId;