diff options
Diffstat (limited to 'src/package/dependency/build.rs')
-rw-r--r-- | src/package/dependency/build.rs | 148 |
1 files changed, 141 insertions, 7 deletions
diff --git a/src/package/dependency/build.rs b/src/package/dependency/build.rs index 8eb8eb3..4d51335 100644 --- a/src/package/dependency/build.rs +++ b/src/package/dependency/build.rs @@ -12,30 +12,164 @@ use anyhow::Result; use serde::Deserialize; use serde::Serialize; -use crate::package::dependency::ParseDependency; -use crate::package::dependency::StringEqual; use crate::package::PackageName; use crate::package::PackageVersionConstraint; +use crate::package::dependency::ParseDependency; +use crate::package::dependency::StringEqual; +use crate::package::dependency::condition::Condition; /// A dependency that is packaged and is only required during build time #[derive(Serialize, Deserialize, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)] -#[serde(transparent)] -pub struct BuildDependency(String); +#[serde(untagged)] +pub enum BuildDependency { + Simple(String), + Conditional { + name: String, + condition: Condition, + }, +} impl AsRef<str> for BuildDependency { fn as_ref(&self) -> &str { - self.0.as_ref() + match self { + BuildDependency::Simple(name) => name, + BuildDependency::Conditional { name, .. } => name, + } } } impl StringEqual for BuildDependency { fn str_equal(&self, s: &str) -> bool { - self.0 == s + match self { + BuildDependency::Simple(name) => name == s, + BuildDependency::Conditional { name, .. } => name == s, + } } } impl ParseDependency for BuildDependency { fn parse_as_name_and_version(&self) -> Result<(PackageName, PackageVersionConstraint)> { - crate::package::dependency::parse_package_dependency_string_into_name_and_version(&self.0) + crate::package::dependency::parse_package_dependency_string_into_name_and_version(self.as_ref()) } } + +#[cfg(test)] +mod tests { + use super::*; + use crate::package::dependency::condition::OneOrMore; + + #[derive(serde::Serialize, serde::Deserialize)] + #[allow(unused)] + pub struct TestSetting { + setting: BuildDependency, + } + + #[test] + fn test_parse_dependency() { + let s: TestSetting = toml::from_str(r#"setting = "foo""#).expect("Parsing TestSetting failed"); + match s.setting { + BuildDependency::Simple(name) => assert_eq!(name, "foo", "Expected 'foo', got {}", name), + other => panic!("Unexpected deserialization to other variant: {:?}", other), + } + } + + #[test] + fn test_parse_conditional_dependency() { + let s: TestSetting = toml::from_str(r#"setting = { name = "foo", condition = { in_image = "bar"} }"#).expect("Parsing TestSetting failed"); + match s.setting { + BuildDependency::Conditional { name, condition } => { + assert_eq!(name, "foo", "Expected 'foo', got {}", name); + assert_eq!(*condition.has_env(), None); + assert_eq!(*condition.env_eq(), None); + assert_eq!(condition.in_image().as_ref(), Some(&OneOrMore::<String>::One(String::from("bar")))); + }, + other => panic!("Unexpected deserialization to other variant: {:?}", other), + } + } + + #[test] + fn test_parse_conditional_dependency_pretty() { + let pretty = r#" + [setting] + name = "foo" + [setting.condition] + in_image = "bar" + "#; + + let s: TestSetting = toml::from_str(pretty).expect("Parsing TestSetting failed"); + + match s.setting { + BuildDependency::Conditional { name, condition } => { + assert_eq!(name, "foo", "Expected 'foo', got {}", name); + assert_eq!(*condition.has_env(), None); + assert_eq!(*condition.env_eq(), None); + assert_eq!(condition.in_image().as_ref(), Some(&OneOrMore::<String>::One(String::from("bar")))); + }, + other => panic!("Unexpected deserialization to other variant: {:?}", other), + } + } + + + #[derive(serde::Serialize, serde::Deserialize)] + #[allow(unused)] + pub struct TestSettings { + settings: Vec<BuildDependency>, + } + + #[test] + fn test_parse_conditional_dependencies() { + let s: TestSettings = toml::from_str(r#"settings = [{ name = "foo", condition = { in_image = "bar"} }]"#).expect("Parsing TestSetting failed"); + match s.settings.get(0).expect("Has not one dependency") { + BuildDependency::Conditional { name, condition } => { + assert_eq!(name, "foo", "Expected 'foo', got {}", name); + assert_eq!(*condition.has_env(), None); + assert_eq!(*condition.env_eq(), None); + assert_eq!(condition.in_image().as_ref(), Some(&OneOrMore::<String>::One(String::from("bar")))); + }, + other => panic!("Unexpected deserialization to other variant: {:?}", other), + } + } + + #[test] + fn test_parse_conditional_dependencies_pretty() { + let pretty = r#" + [[settings]] + name = "foo" + condition = { in_image = "bar" } + "#; + + let s: TestSettings = toml::from_str(pretty).expect("Parsing TestSetting failed"); + + match s.settings.get(0).expect("Has not one dependency") { + BuildDependency::Conditional { name, condition } => { + assert_eq!(name, "foo", "Expected 'foo', got {}", name); + assert_eq!(*condition.has_env(), None); + assert_eq!(*condition.env_eq(), None); + assert_eq!(condition.in_image().as_ref(), Some(&OneOrMore::<String>::One(String::from("bar")))); + }, + other => panic!("Unexpected deserialization to other variant: {:?}", other), + } + } + + #[test] + fn test_parse_conditional_dependencies_pretty_2() { + let pretty = r#" + [[settings]] + name = "foo" + condition.in_image = "bar" + "#; + + let s: TestSettings = toml::from_str(pretty).expect("Parsing TestSetting failed"); + + match s.settings.get(0).expect("Has not one dependency") { + BuildDependency::Conditional { name, condition } => { + assert_eq!(name, "foo", "Expected 'foo', got {}", name); + assert_eq!(*condition.has_env(), None); + assert_eq!(*condition.env_eq(), None); + assert_eq!(condition.in_image().as_ref(), Some(&OneOrMore::<String>::One(String::from("bar")))); + }, + other => panic!("Unexpected deserialization to other variant: {:?}", other), + } + } +} + |