1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use error::{HcResult, HolochainError};

lazy_static! {
    pub static ref HDK_VERSION: HDKVersion = {
        let version = env!(
            "HDK_VERSION",
            "failed to obtain hdk version from build environment. Check build.rs"
        );
        HDKVersion::new(version).unwrap_or_else(|_| {
            panic!("Failed to create HDK Version '{}'. Check Build.rs", version)
        })
    };
}

#[derive(Clone, PartialEq, Eq)]
pub enum Lifecycle {
    Beta(i16),
    Alpha(i16),
    Stable(i16),
}

#[derive(Clone, PartialEq, Eq)]
pub struct HDKVersion {
    versioning: (i16, i16, i16),
    lifecycle: Lifecycle,
}

fn get_lifecycle(lifecycle_string: &str) -> HcResult<Lifecycle> {
    if lifecycle_string.contains("beta") {
        Ok(Lifecycle::Beta(
            lifecycle_string
                .split("beta")
                .nth(1)
                .ok_or("Could not get beta version")?
                .parse::<i16>()
                .map_err(|_| {
                    HolochainError::ErrorGeneric(format!(
                        "Could not parse beta version: {:?}",
                        lifecycle_string
                    ))
                })?,
        ))
    } else if lifecycle_string.contains("stable") {
        Ok(Lifecycle::Stable(
            lifecycle_string
                .split("stable")
                .nth(1)
                .ok_or("Could not get stable version")?
                .parse::<i16>()
                .map_err(|_| {
                    HolochainError::ErrorGeneric(format!(
                        "Could not parse stable version: {:?}",
                        lifecycle_string
                    ))
                })?,
        ))
    } else if lifecycle_string.contains("alpha") {
        Ok(Lifecycle::Alpha(
            lifecycle_string
                .split("alpha")
                .nth(1)
                .ok_or("Could not get alpha version")?
                .parse::<i16>()
                .map_err(|_| {
                    HolochainError::ErrorGeneric(format!(
                        "Could not parse alpha version: {:?}",
                        lifecycle_string
                    ))
                })?,
        ))
    } else {
        Err(HolochainError::ErrorGeneric(
            "Invalid Lifecycle Version".to_string(),
        ))
    }
}

impl ToString for HDKVersion {
    fn to_string(&self) -> String {
        let version = vec![
            self.versioning.0.to_string(),
            self.versioning.1.to_string(),
            self.versioning.2.to_string(),
        ]
        .join(".");
        let life_cycle = match self.lifecycle {
            Lifecycle::Alpha(num) => vec!["alpha", &num.to_string()].join(""),
            Lifecycle::Beta(num) => vec!["beta", &num.to_string()].join(""),
            Lifecycle::Stable(num) => vec!["stable", &num.to_string()].join(""),
        };
        vec![version, life_cycle].join("-")
    }
}

impl HDKVersion {
    pub fn new(version_string: &str) -> HcResult<HDKVersion> {
        let mut splits = version_string.split('-');
        let version = splits.next().ok_or("Could not get version")?;

        let mut version_splits = version.trim_start_matches('v').split('.');
        let versioning = (
            version_splits
                .next()
                .ok_or("Could not get version")?
                .parse::<i16>()
                .map_err(|_| {
                    HolochainError::ErrorGeneric(format!(
                        "Could not parse version 1st segment: {:?}",
                        &version_string
                    ))
                })?,
            version_splits
                .next()
                .ok_or("Could not get version")?
                .parse::<i16>()
                .map_err(|_| {
                    HolochainError::ErrorGeneric(format!(
                        "Could not parse version 2nd segment: {:?}",
                        &version_string
                    ))
                })?,
            version_splits
                .next()
                .ok_or("Could not get version")?
                .parse::<i16>()
                .map_err(|_| {
                    HolochainError::ErrorGeneric(format!(
                        "Could not parse version 3rd segment: {:?}",
                        &version_string
                    ))
                })?,
        );

        let lifecycle = get_lifecycle(splits.next().ok_or("Could not get lifecycle")?)?;

        Ok(HDKVersion {
            versioning,
            lifecycle,
        })
    }
}