path: root/src/package/dependency/condition.rs

//
// Copyright (c) 2020-2021 science+computing ag and other contributors
//
// This program and the accompanying materials are made
// available under the terms of the Eclipse Public License 2.0
// which is available at https://www.eclipse.org/legal/epl-2.0/
//
// SPDX-License-Identifier: EPL-2.0
//

use std::collections::HashMap;

use serde::Deserialize;
use serde::Serialize;
use getset::Getters;
use anyhow::Result;

use crate::util::EnvironmentVariableName;
use crate::util::docker::ImageName;

/// The Condition type
///
/// This type represents a condition whether a dependency should be included in the package tree or
/// not.
///
/// Right now, we are supporting condition by environment (set or equal) or whether a specific
/// build image is used.
/// All these settings are optional, of course.
///
#[derive(Serialize, Deserialize, Getters, Clone, Debug, Eq, PartialEq)]
pub struct Condition {
    #[serde(rename = "has_env", skip_serializing_if = "Option::is_none")]
    #[getset(get = "pub")]
    pub(super) has_env: Option<OneOrMore<EnvironmentVariableName>>,

    #[serde(rename = "env_eq", skip_serializing_if = "Option::is_none")]
    #[getset(get = "pub")]
    pub(super) env_eq: Option<HashMap<EnvironmentVariableName, String>>,

    #[serde(rename = "in_image", skip_serializing_if = "Option::is_none")]
    #[getset(get = "pub")]
    pub(super) in_image: Option<OneOrMore<String>>,
}

impl Condition {
    #[cfg(test)]
    pub fn new(has_env: Option<OneOrMore<EnvironmentVariableName>>,
               env_eq: Option<HashMap<EnvironmentVariableName, String>>,
               in_image: Option<OneOrMore<String>>)
        -> Self
    {
        Condition { has_env, env_eq, in_image }
    }

    /// Check whether the condition matches a certain set of data
    ///
    /// # Return value
    ///
    /// Always returns Ok(_) in the current implementation
    pub fn matches(&self, data: &ConditionData<'_>) -> Result<bool> {
        if !self.matches_env_cond(data)? {
            return Ok(false)
        }

        if !self.matches_env_eq_cond(data)? {
            return Ok(false)
        }

        if !self.matches_in_image_cond(data)? {
            return Ok(false)
        }

        Ok(true)
    }

    fn matches_env_cond(&self, data: &ConditionData<'_>) -> Result<bool> {
        if let Some(has_env_cond) = self.has_env.as_ref() {
            let b = match has_env_cond {
                OneOrMore::One(env) => data.env.iter().any(|(name, _)| env == name),
                OneOrMore::More(envs) => envs.iter().all(|required_env| {
                    data.env
                        .iter()
                        .any(|(name, _)| name == required_env)
                })
            };

            if !b {
                return Ok(false)
            }
        }

        Ok(true)
    }

    fn matches_env_eq_cond(&self, data: &ConditionData<'_>) -> Result<bool> {
        if let Some(env_eq_cond) = self.env_eq.as_ref() {
            let b = env_eq_cond.iter()
                .all(|(req_env_name, req_env_val)| {
                    data.env
                        .iter()
                        .find(|(env_name, _)| env_name == req_env_name)
                        .map(|(_, env_val)| env_val == req_env_val)
                        .unwrap_or(false)
                });

            if !b {
                return Ok(false)
            }
        }

        Ok(true)
    }

    fn matches_in_image_cond(&self, data: &ConditionData<'_>) -> Result<bool> {
        if let Some(in_image_cond) = self.in_image.as_ref() {
            let b = match in_image_cond {
                OneOrMore::One(req_image) => {
                    // because the image_name in the ConditionData is Option,
                    // which is a design-decision because the image can be not-specified (in the
                    // "tree-of" subcommand),
                    // we automatically use `false` as value here.
                    //
                    // That is because if we need to have a certain image (which is what this
                    // condition expresses), and there is no image specified in the ConditionData,
                    // we are by definition are NOT in this image.
                    data.image_name
                        .as_ref()
                        .map(|i| i.as_ref() == req_image)
                        .unwrap_or(false)
                },
                OneOrMore::More(req_images) => {
                    req_images.iter()
                        .any(|ri| {
                            data.image_name
                                .as_ref()
                                .map(|inam| inam.as_ref() == ri)
                                .unwrap_or(false)
                        })
                },
            };

            Ok(b)
        } else {
            Ok(true)
        }
    }
}

/// Manual implementation of PartialOrd for Condition
///
/// Because HashMap does not implement PartialOrd
impl PartialOrd for Condition {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        use std::cmp::Ordering as O;

        let cmp_has_env = match (self.has_env.as_ref(), other.has_env.as_ref()) {
            (Some(a), Some(b)) => a.partial_cmp(b),
            (Some(_), None)    => Some(O::Greater),
            (None, Some(_))    => Some(O::Less),
            (None, None)       => Some(O::Equal),
        };

        if cmp_has_env.as_ref().map(|o| *o != O::Equal).unwrap_or(false) {
            return cmp_has_env
        }

        let cmp_env_eq = match (self.env_eq.as_ref(), other.env_eq.as_ref()) {
            // TODO: Is this safe? We ignore the HashMaps here and just say they are equal. They are most certainly not.
            (Some(_), Some(_)) => Some(O::Equal),
            (Some(_), None)    => Some(O::Greater),
            (None, Some(_))    => Some(O::Less),
            (None, None)       => Some(O::Equal),
        };

        if cmp_env_eq.as_ref().map(|o| *o != O::Equal).unwrap_or(false) {
            return cmp_env_eq
        }

        match (self.in_image.as_ref(), other.in_image.as_ref()) {
            (Some(a), Some(b)) => a.partial_cmp(b),
            (Some(_), None)    => Some(O::Greater),
            (None, Some(_))    => Some(O::Less),
            (None, None)       => Some(O::Equal),
        }
    }
}

/// Manual implementation of Ord for Condition
///
/// Because HashMap does not implement Ord
impl Ord for Condition {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.partial_cmp(other).unwrap_or(std::cmp::Ordering::Equal)
    }
}

/// Manual implementation of Hash for Condition
///
/// Because HashMap does not implement Hash
impl std::hash::Hash for Condition {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.has_env.hash(state);
        if let Some(hm) = self.env_eq.as_ref() {
            hm.iter().for_each(|(k, v)| (k, v).hash(state));
        };
        self.in_image.hash(state);
    }
}


/// Helper type for supporting Vec<T> and T in value
/// position of Condition
#[derive(Serialize, Deserialize, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
#[serde(untagged)]
pub enum OneOrMore<T: Sized> {
    One(T),
    More(Vec<T>),
}

impl<T: Sized> Into<Vec<T>> for OneOrMore<T> {
    fn into(self) -> Vec<T> {
        match self {
            OneOrMore::One(o) => vec!