ud 0.1.0

UpDate! — A fast, universal dependency updater.
Documentation
/// string_newtypes! generates the model's string newtypes.
///
/// Expansion:
/// ```ignore
/// #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
/// #[serde(transparent)]
/// pub struct Coordinate(pub String);
/// ...
/// ```
#[macro_export]
macro_rules! string_newtypes {
    ($($name:ident),+ $(,)?) => { $(
        #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
        #[serde(transparent)]
        pub struct $name(pub String);
        impl $name {
            pub fn as_str(&self) -> &str {
                &self.0
            }
        }
        impl<S: Into<String>> From<S> for $name {
            fn from(s: S) -> Self {
                Self(s.into())
            }
        }
        impl std::fmt::Display for $name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(f, "{}", self.0)
            }
        }
    )+ };
}

/// ecosystem! generates the wiring declaration.
///
/// Expansion:
/// ```ignore
/// pub fn rust() -> ud::core::contract::Ecosystem { ... }
/// ```
#[macro_export]
macro_rules! ecosystem {
    ( name: $name:ident,
      manifests:  [ $($m:expr),+ $(,)? ],
      registries: [ $($r:expr),+ $(,)? ],
      scheme: $s:expr $(,)? ) => {
        pub fn $name() -> $crate::core::contract::Ecosystem {
            $crate::core::contract::Ecosystem {
                name: stringify!($name),
                manifests:  vec![ $(std::sync::Arc::new($m)),+ ],
                registries: vec![ $(std::sync::Arc::new($r)),+ ],
                scheme: std::sync::Arc::new($s),
            }
        }
    };
}

/// http_registry! generates HTTP registry boilerplate.
///
/// Expansion:
/// ```ignore
/// pub struct CratesRegistry { ... }
/// impl Registry for CratesRegistry { ... }
/// ```
#[macro_export]
macro_rules! http_registry {
    ( $($struct_name:ident { id: $id:expr, base: $base:expr }),+ $(,)? ) => { $(
        pub struct $struct_name {
            base_url: String,
            client: reqwest::Client,
        }
        impl Default for $struct_name {
            fn default() -> Self {
                Self::new()
            }
        }
        impl $struct_name {
            pub fn new() -> Self {
                Self {
                    base_url: $base.to_string(),
                    client: reqwest::Client::builder()
                        .user_agent("ud (https://github.com/Yrrrrrf/ud)")
                        .build()
                        .unwrap(),
                }
            }
            pub fn with_base_url(base_url: &str) -> Self {
                Self {
                    base_url: base_url.to_string(),
                    client: reqwest::Client::builder()
                        .user_agent("ud (https://github.com/Yrrrrrf/ud)")
                        .build()
                        .unwrap(),
                }
            }
        }
        impl $struct_name {
            pub const REGISTRY_ID: &'static str = $id;
        }
    )+ };
}

/// scheme_cases! generates table-driven scheme conformance tests.
///
/// Expansion:
/// ```ignore
/// #[test]
/// fn node_bare_is_exact() {
///     let scheme = NodeScheme;
///     assert_eq!(scheme.satisfies(&Version::from("1.0.0"), &Constraint::from("1.0.0")), true);
///     ...
/// }
/// ```
#[macro_export]
macro_rules! scheme_cases {
    ($name:ident, $scheme:expr, satisfies; $(($v:expr, $c:expr) => $expected:expr),+ $(,)?) => {
        #[test]
        fn $name() {
            let scheme = $scheme;
            $(
                let v = $crate::core::model::Version::from($v);
                let c = $crate::core::model::Constraint::from($c);
                assert_eq!(scheme.satisfies(&v, &c), $expected, "satisfies({}, {}) expected {}", $v, $c, $expected);
            )+
        }
    };
    ($name:ident, $scheme:expr, cmp; $(($a:expr, $b:expr) => $expected:expr),+ $(,)?) => {
        #[test]
        fn $name() {
            let scheme = $scheme;
            $(
                let a = $crate::core::model::Version::from($a);
                let b = $crate::core::model::Version::from($b);
                assert_eq!(scheme.cmp(&a, &b), $expected, "cmp({}, {}) expected {:?}", $a, $b, $expected);
            )+
        }
    };
    ($name:ident, $scheme:expr, is_prerelease; $(($v:expr) => $expected:expr),+ $(,)?) => {
        #[test]
        fn $name() {
            let scheme = $scheme;
            $(
                let v = $crate::core::model::Version::from($v);
                assert_eq!(scheme.is_prerelease(&v), $expected, "is_prerelease({}) expected {}", $v, $expected);
            )+
        }
    };
    ($name:ident, $scheme:expr, declared_floor; $(($c:expr) => $expected:expr),+ $(,)?) => {
        #[test]
        fn $name() {
            let scheme = $scheme;
            $(
                let c = $crate::core::model::Constraint::from($c);
                let expected = $expected.map($crate::core::model::Version::from);
                assert_eq!(scheme.declared_floor(&c), expected, "declared_floor({}) expected {:?}", $c, expected);
            )+
        }
    };
    ($name:ident, $scheme:expr, rewrite; $(($c:expr, $target:expr) => $expected:expr),+ $(,)?) => {
        #[test]
        fn $name() {
            let scheme = $scheme;
            $(
                let c = $crate::core::model::Constraint::from($c);
                let target = $crate::core::model::Version::from($target);
                let expected = $expected.map($crate::core::model::Constraint::from);
                assert_eq!(scheme.rewrite(&c, &target), expected, "rewrite({}, {}) expected {:?}", $c, $target, expected);
            )+
        }
    };
}