feat: use librepages/libconfig for handling deployment configurations

Cargo.toml

@@ -21,6 +21,7 @@ actix-web-codegen-const-routes = { version = "0.1.0", tag = "0.1.0", git = "http
 argon2-creds = { branch = "master", git = "https://github.com/realaravinth/argon2-creds"}
 sqlx = { version = "0.6.1", features = ["runtime-actix-rustls", "postgres", "time", "offline", "json", "uuid"] }
 clap = { version = "3.2.20", features = ["derive"]}
+libconfig = { version = "0.1.0", git = "https://git.batsense.net/librepages/libconfig" }
 
 config = "0.13"
 git2 = "0.14.2"

src/ctx/api/v1/pages.rs

@@ -61,7 +61,7 @@ impl Ctx {
         self.db.add_site(&db_site).await?;
         let page = Page::from_site(&self.settings, db_site);
         page.update(&page.branch)?;
-        if let Some(_config) = page_config::Config::load(&page.path, &page.branch) {
+        if let Some(_config) = page_config::load(&page.path, &page.branch) {
             unimplemented!();
         }
         self.db
@@ -87,7 +87,7 @@ impl Ctx {
                 .unwrap();
             }
             rx.await.unwrap()?;
-            if let Some(_config) = page_config::Config::load(&page.path, &page.branch) {
+            if let Some(_config) = page_config::load(&page.path, &page.branch) {
                 unimplemented!();
             }
             self.db

src/page_config.rs

@@ -16,41 +16,11 @@
  */
 use std::path::Path;
 
+use libconfig::Config;
 use serde::{Deserialize, Serialize};
 
 use crate::git::{ContentType, GitFileMode};
 
-#[derive(Deserialize, Serialize, Debug, Eq, PartialEq, Clone)]
-pub struct Config {
-    pub source: Source,
-    pub domains: Option<Vec<String>>,
-    pub forms: Option<Forms>,
-    pub image_compression: Option<ImageCompression>,
-    pub redirects: Option<Vec<Redirects>>,
-}
-
-#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone)]
-pub struct Source {
-    production_branch: String,
-    staging: Option<String>,
-}
-
-#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone)]
-pub struct Forms {
-    pub enable: bool,
-}
-
-#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone)]
-pub struct ImageCompression {
-    pub enable: bool,
-}
-
-#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone)]
-pub struct Redirects {
-    pub from: String,
-    pub to: String,
-}
-
 #[derive(Deserialize, Debug, Serialize, PartialEq, Eq)]
 struct Policy<'a> {
     rel_path: &'a str,
@@ -70,77 +40,75 @@ enum SupportedFormat {
     Toml,
 }
 
-impl Config {
+pub fn load<P: AsRef<Path>>(repo_path: &P, branch: &str) -> Option<Config> {
-    pub fn load<P: AsRef<Path>>(repo_path: &P, branch: &str) -> Option<Config> {
+    const POLICIES: [Policy; 2] = [
-        const POLICIES: [Policy; 2] = [
+        Policy::new("librepages.toml", SupportedFormat::Toml),
-            Policy::new("librepages.toml", SupportedFormat::Toml),
+        Policy::new("librepages.json", SupportedFormat::Json),
-            Policy::new("librepages.json", SupportedFormat::Json),
+    ];
-        ];
 
-        if let Some(policy) = Self::discover(repo_path, branch, &POLICIES) {
+    if let Some(policy) = discover(repo_path, branch, &POLICIES) {
-            //            let path = p.repo.as_ref().join(policy.rel_path);
+        //            let path = p.repo.as_ref().join(policy.rel_path);
-            //let contents = fs::read_to_string(path).await.unwrap();
+        //let contents = fs::read_to_string(path).await.unwrap();
 
-            let file =
+        let file =
-                crate::git::read_preview_file(&repo_path.as_ref().into(), branch, policy.rel_path)
+            crate::git::read_preview_file(&repo_path.as_ref().into(), branch, policy.rel_path)
-                    .unwrap();
+                .unwrap();
-            if let ContentType::Text(contents) = file.content {
+        if let ContentType::Text(contents) = file.content {
-                let res = match policy.format {
+            let res = match policy.format {
-                    SupportedFormat::Json => Self::load_json(&contents),
+                SupportedFormat::Json => load_json(&contents),
-                    SupportedFormat::Yaml => Self::load_yaml(&contents),
+                SupportedFormat::Yaml => load_yaml(&contents),
-                    SupportedFormat::Toml => Self::load_toml(&contents),
+                SupportedFormat::Toml => load_toml(&contents),
-                };
-
-                return Some(res);
             };
-        }
 
-        None
+            return Some(res);
+        };
     }
-    fn discover<'a, P: AsRef<Path>>(
-        repo_path: &P,
-        branch: &str,
-        policies: &'a [Policy<'a>],
-    ) -> Option<&'a Policy<'a>> {
-        let repo = git2::Repository::open(repo_path).unwrap();
 
-        let branch = repo.find_branch(branch, git2::BranchType::Local).unwrap();
+    None
-        //    let tree = head.peel_to_tree().unwrap();
+}
-        let branch = branch.into_reference();
+fn discover<'a, P: AsRef<Path>>(
-        let tree = branch.peel_to_tree().unwrap();
+    repo_path: &P,
+    branch: &str,
+    policies: &'a [Policy<'a>],
+) -> Option<&'a Policy<'a>> {
+    let repo = git2::Repository::open(repo_path).unwrap();
 
-        for p in policies.iter() {
+    let branch = repo.find_branch(branch, git2::BranchType::Local).unwrap();
-            let file_exists = tree.iter().any(|x| {
+    //    let tree = head.peel_to_tree().unwrap();
-                if let Some(name) = x.name() {
+    let branch = branch.into_reference();
-                    if policies.iter().any(|p| p.rel_path == name) {
+    let tree = branch.peel_to_tree().unwrap();
-                        let mode: GitFileMode = x.into();
+
-                        matches!(mode, GitFileMode::Executable | GitFileMode::Regular)
+    for p in policies.iter() {
-                    } else {
+        let file_exists = tree.iter().any(|x| {
-                        false
+            if let Some(name) = x.name() {
-                    }
+                if policies.iter().any(|p| p.rel_path == name) {
+                    let mode: GitFileMode = x.into();
+                    matches!(mode, GitFileMode::Executable | GitFileMode::Regular)
                 } else {
                     false
                 }
-            });
+            } else {
-
+                false
-            if file_exists {
-                return Some(p);
             }
+        });
+
+        if file_exists {
+            return Some(p);
         }
-        None
     }
+    None
+}
 
-    fn load_toml(c: &str) -> Config {
+fn load_toml(c: &str) -> Config {
-        toml::from_str(c).unwrap()
+    toml::from_str(c).unwrap()
-    }
+}
 
-    fn load_yaml(c: &str) -> Config {
+fn load_yaml(c: &str) -> Config {
-        serde_yaml::from_str(c).unwrap()
+    serde_yaml::from_str(c).unwrap()
-    }
+}
 
-    fn load_json(c: &str) -> Config {
+fn load_json(c: &str) -> Config {
-        serde_json::from_str(c).unwrap()
+    serde_json::from_str(c).unwrap()
-    }
 }
 
 #[cfg(test)]
@@ -149,6 +117,8 @@ mod tests {
     use crate::git::tests::write_file_util;
     use mktemp::Temp;
 
+    use libconfig::*;
+
     #[actix_rt::test]
     async fn page_config_test() {
         let tmp_dir = Temp::new_dir().unwrap();
@@ -167,7 +137,7 @@ mod tests {
             Some(&content),
         );
 
-        let config = Config::load(&repo_path, "master").unwrap();
+        let config = load(&repo_path, "master").unwrap();
         assert!(config.forms.as_ref().unwrap().enable);
         assert!(config.image_compression.as_ref().unwrap().enable);
         assert_eq!(config.source.production_branch, "librepages");