From fadbe48b053a865cf72f6dee6aae6bcca5c795a8 Mon Sep 17 00:00:00 2001
From: Thomas Eppers <thomas@ThinkPad-T460-fd3f4cef.localdomain>
Date: Sat, 11 Sep 2021 11:07:56 +0200
Subject: [PATCH] WIP

---
 src/common.rs |   5 ++
 src/main.rs   |   2 +
 src/repo.rs   | 143 ++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 150 insertions(+)
 create mode 100644 src/common.rs
 create mode 100644 src/repo.rs

diff --git a/src/common.rs b/src/common.rs
new file mode 100644
index 0000000..2c0c08c
--- /dev/null
+++ b/src/common.rs
@@ -0,0 +1,5 @@
+pub fn remove_last_char(input: &str) -> &str {
+    let mut chars = input.chars();
+    chars.next_back();
+    chars.as_str()
+}
diff --git a/src/main.rs b/src/main.rs
index 6374c95..4264d15 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,3 +1,5 @@
+mod common;
+mod repo;
 mod tags;
 mod ui;
 mod widget;
diff --git a/src/repo.rs b/src/repo.rs
new file mode 100644
index 0000000..5ead10c
--- /dev/null
+++ b/src/repo.rs
@@ -0,0 +1,143 @@
+use crate::common;
+
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    Conversion,
+    Empty,
+    NoTagFound,
+    InvalidChar,
+    MisformedInput,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum Repo {
+    WithServer(String, String, String),
+    WithOrga(String, String),
+    Project(String),
+}
+
+// pub fn extract_yaml(repo: &str) -> (String, String, String, String) {
+//     let regex = regex::Regex::new(r"( *image *:) *([^/])??/([^/:]):?(.*)?");
+// }
+
+pub fn split_repo(repo: &str) -> Result<Repo, Error> {
+    let split_tag: Vec<&str> = repo.split(":").collect();
+    if split_tag.len() == 2 && split_tag[0].len() != 0 && split_tag[1].len() != 0 {
+        //
+    }
+    Ok(Repo::Project("".into()))
+}
+
+pub fn split_repo_without_tag(mut repo: &str) -> Result<Repo, Error> {
+    repo.trim();
+    let split_repo: Vec<&str> = repo.split("/").collect();
+    match split_repo.len() {
+        1 => {
+            let regex = regex::Regex::new(r"[a-z0-9]+").unwrap();
+            match regex.is_match(repo) {
+                false => Err(Error::MisformedInput),
+                true => Ok(Repo::Project(split_repo[0].into())),
+            }
+        }
+        2 => {
+            let regex = regex::Regex::new(r"[a-z0-9]+/[a-z0-9]+").unwrap();
+            match regex.is_match(repo) {
+                false => Err(Error::MisformedInput),
+                true => Ok(Repo::WithOrga(split_repo[0].into(), split_repo[1].into())),
+            }
+        }
+        3 => {
+            let regex = regex::Regex::new(r"[a-z0-9\.]+/[a-z0-9]+/[a-z0-9]+").unwrap();
+            match regex.is_match(repo) {
+                false => Err(Error::MisformedInput),
+                true => Ok(Repo::WithServer(
+                    split_repo[0].into(),
+                    split_repo[1].into(),
+                    split_repo[2].into(),
+                )),
+            }
+        }
+        _ => Err(Error::MisformedInput),
+    }
+}
+
+pub fn split_tag(repo: &str) -> Result<(&str, &str), Error> {
+    let split_tag: Vec<&str> = repo.split(":").collect();
+    if split_tag.len() == 2 && split_tag[0].len() != 0 && split_tag[1].len() != 0 {
+        Ok((split_tag[0], split_tag[1]))
+    } else {
+        Err(Error::NoTagFound)
+    }
+}
+
+// fn
+
+pub fn extract(repo: &str) -> Result<(Option<&str>, Option<&str>, &str), Error> {
+    if repo.len() == 0 {
+        return Err(Error::Empty);
+    }
+    let regex = regex::Regex::new(r"([^/:]*?/)??([^/:]*?/)?([^/:]*):?(.*)?").unwrap();
+    let caps = match regex.captures(repo) {
+        None => return Err(Error::Conversion),
+        Some(cap) => cap,
+    };
+    let server = match caps.get(1) {
+        None => None,
+        Some(cap) => Some(common::remove_last_char(cap.as_str())),
+    };
+    let orga = match caps.get(2) {
+        None => None,
+        Some(cap) => Some(common::remove_last_char(cap.as_str())),
+    };
+
+    Ok((server, orga, caps.get(3).unwrap().as_str()))
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::repo;
+    use crate::repo::{Error, Repo};
+
+    // #[test]
+    fn test_repo_regex() {
+        assert_eq!(repo::extract(""), Err(repo::Error::Empty));
+        assert_eq!(
+            repo::extract("ghcr.io/library/nginx"),
+            Ok((Some("ghcr.io"), Some("library"), "nginx"))
+        );
+        assert_eq!(
+            repo::extract("library/nginx"),
+            Ok((None, Some("library"), "nginx"))
+        );
+        assert_eq!(repo::extract("nginx"), Ok((None, None, "nginx")));
+    }
+
+    #[test]
+    fn split_tag() {
+        assert_eq!(repo::split_tag("nginx:v1"), Ok(("nginx", "v1")));
+        assert_eq!(repo::split_tag("dsfsdf"), Err(repo::Error::NoTagFound));
+        assert_eq!(repo::split_tag("nginx:"), Err(repo::Error::NoTagFound));
+        assert_eq!(repo::split_tag(":v1"), Err(repo::Error::NoTagFound));
+        assert_eq!(repo::split_tag(":"), Err(repo::Error::NoTagFound));
+    }
+
+    #[test]
+    fn test_split_repo_without_tag() {
+        use crate::repo::split_repo_without_tag as test_fn;
+        assert_eq!(test_fn(""), Err(Error::MisformedInput));
+        assert_eq!(test_fn("NGINX"), Err(Error::MisformedInput));
+        assert_eq!(test_fn("nginx"), Ok(Repo::Project("nginx".into())));
+        assert_eq!(
+            test_fn("library/nginx"),
+            Ok(Repo::WithOrga("library".into(), "nginx".into()))
+        );
+        assert_eq!(
+            test_fn("ghcr.io/library/nginx"),
+            Ok(Repo::WithServer(
+                "ghcr.io".into(),
+                "library".into(),
+                "nginx".into(),
+            ))
+        );
+    }
+}