Split dependency types into submodule

This patch splits the src/package/dependency.rs file contents into
submodules.

Signed-off-by: Matthias Beyer <mail@beyermatthias.de>

5 files changed, 164 insertions, 0 deletions

diff --git a/src/package/dependency/build.rs b/src/package/dependency/build.rs
new file mode 100644
index 0000000..0f8c0c1
--- /dev/null
+++ b/src/package/dependency/build.rs
@@ -0,0 +1,14 @@
+use serde::Deserialize;
+
+use crate::package::dependency::StringEqual;
+
+/// A dependency that is packaged and is only required during build time
+#[derive(Deserialize, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
+#[serde(transparent)]
+pub struct BuildDependency(String);
+
+impl StringEqual for BuildDependency {
+    fn str_equal(&self, s: &str) -> bool {
+        self.0 == s
+    }
+}
diff --git a/src/package/dependency/mod.rs b/src/package/dependency/mod.rs
new file mode 100644
index 0000000..f2f0b8a
--- /dev/null
+++ b/src/package/dependency/mod.rs
@@ -0,0 +1,69 @@
+mod system;
+pub use system::*;
+
+mod system_runtime;
+pub use system_runtime::*;
+
+mod build;
+pub use build::*;
+
+mod runtime;
+pub use runtime::*;
+
+pub trait StringEqual {
+    fn str_equal(&self, s: &str) -> bool;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::convert::TryInto;
+
+    use crate::package::Package;
+    use crate::package::PackageName;
+    use crate::package::PackageVersion;
+    use crate::package::PackageVersionConstraint;
+
+    //
+    // helper functions
+    //
+
+    fn name(s: &'static str) -> PackageName {
+        PackageName::from(String::from(s))
+    }
+
+    fn exact(s: &'static str) -> PackageVersionConstraint {
+        PackageVersionConstraint::Exact(PackageVersion::from(String::from(s)))
+    }
+
+    fn higher_as(s: &'static str) -> PackageVersionConstraint {
+        PackageVersionConstraint::HigherAs(PackageVersion::from(String::from(s)))
+    }
+
+    //
+    // tests
+    //
+
+    #[test]
+    fn test_dependency_conversion_1() {
+        let s = "vim =8.2";
+        let d = Dependency::from(String::from(s));
+
+        let (n, c) = d.try_into().unwrap();
+
+        assert_eq!(n, name("vim"));
+        assert_eq!(c, exact("8.2"));
+    }
+
+    #[test]
+    fn test_dependency_conversion_2() {
+        let s = "gtk15 >1b";
+        let d = Dependency::from(String::from(s));
+
+        let (n, c) = d.try_into().unwrap();
+
+        assert_eq!(n, name("gtk15"));
+        assert_eq!(c, higher_as("1b"));
+    }
+}
diff --git a/src/package/dependency/runtime.rs b/src/package/dependency/runtime.rs
new file mode 100644
index 0000000..5096469
--- /dev/null
+++ b/src/package/dependency/runtime.rs
@@ -0,0 +1,51 @@
+use std::result::Result as RResult;
+use serde::Deserialize;
+use regex::Regex;
+use lazy_static::lazy_static;
+use anyhow::anyhow;
+
+use crate::package::PackageName;
+use crate::package::PackageVersionConstraint;
+use crate::package::dependency::StringEqual;
+
+
+/// A dependency that is packaged and is required during runtime
+#[derive(Deserialize, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
+#[serde(transparent)]
+pub struct Dependency(String);
+
+impl StringEqual for Dependency {
+    fn str_equal(&self, s: &str) -> bool {
+        self.0 == s
+    }
+}
+
+impl From<String> for Dependency {
+    fn from(s: String) -> Dependency {
+        Dependency(s)
+    }
+}
+
+impl std::convert::TryInto<(PackageName, PackageVersionConstraint)> for Dependency {
+    type Error = anyhow::Error;
+
+    fn try_into(self) -> RResult<(PackageName, PackageVersionConstraint), Self::Error> {
+        lazy_static! {
+            static ref RE: Regex = Regex::new("^(?P<name>[[:alpha:]]([[[:alnum:]]-_])*) (?P<version>([\\*=><])?[[:alnum:]]([[[:alnum:]][[:punct:]]])*)$").unwrap();
+        }
+
+        let caps = RE.captures(&self.0)
+            .ok_or_else(|| anyhow!("Could not parse into package name and package version constraint: '{}'", self.0))?;
+
+        let name = caps.name("name")
+            .ok_or_else(|| anyhow!("Could not parse name: '{}'", self.0))?;
+
+        let vers = caps.name("version")
+            .ok_or_else(|| anyhow!("Could not parse version: '{}'", self.0))?;
+
+        let constraint = PackageVersionConstraint::parse(vers.as_str())?;
+
+        Ok((PackageName::from(String::from(name.as_str())), constraint))
+    }
+}
+
diff --git a/src/package/dependency/system.rs b/src/package/dependency/system.rs
new file mode 100644
index 0000000..aa5241c
--- /dev/null
+++ b/src/package/dependency/system.rs
@@ -0,0 +1,15 @@
+use serde::Deserialize;
+
+use crate::package::dependency::StringEqual;
+
+/// A dependency that can be installed from the system and is only required during build
+#[derive(Deserialize, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
+#[serde(transparent)]
+pub struct SystemBuildDependency(String);
+
+impl StringEqual for SystemBuildDependency {
+    fn str_equal(&self, s: &str) -> bool {
+        self.0 == s
+    }
+}
+
diff --git a/src/package/dependency/system_runtime.rs b/src/package/dependency/system_runtime.rs
new file mode 100644
index 0000000..1764102
--- /dev/null
+++ b/src/package/dependency/system_runtime.rs
@@ -0,0 +1,15 @@
+use serde::Deserialize;
+
+use crate::package::dependency::StringEqual;
+
+/// A dependency that can be installed from the system and is required during runtime
+#[derive(Deserialize, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
+#[serde(transparent)]
+pub struct SystemDependency(String);
+
+impl StringEqual for SystemDependency {
+    fn str_equal(&self, s: &str) -> bool {
+        self.0 == s
+    }
+}
+