feat: add builder

src/build_util.rs

@@ -0,0 +1,64 @@
+use std::env;
+use std::path::PathBuf;
+use rust_util::XResult;
+
+pub enum Builder {
+    Cargo,
+    Maven,
+    Gradle,
+    Buildj,
+    Unknown,
+}
+
+impl Builder {
+    pub fn from(opt_current_dir: &Option<String>) -> XResult<Self> {
+        inner_get_builder(opt_current_dir)
+    }
+
+    pub fn get_name(&self) -> Option<String> {
+        match self {
+            Builder::Cargo => Some("cargo".into()),
+            Builder::Maven => Some("mvn".into()),
+            Builder::Gradle => Some("gradle".into()),
+            Builder::Buildj => Some("buildj".into()),
+            Builder::Unknown => None,
+        }
+    }
+}
+
+fn inner_get_builder(opt_current_dir: &Option<String>) -> XResult<Builder> {
+    let work_dir = get_work_dir(opt_current_dir)?;
+    let work_dir_path_buf = PathBuf::from(&work_dir);
+
+    let check_files_exists = |f: &str| -> bool {
+        let mut work_dir_path_buf_f = work_dir_path_buf.clone();
+        work_dir_path_buf_f.push(f);
+        work_dir_path_buf_f.exists()
+    };
+
+    if check_files_exists("Cargo.toml") {
+        return Ok(Builder::Cargo);
+    }
+    if check_files_exists("pom.xml") {
+        return Ok(Builder::Maven);
+    }
+    if check_files_exists("build.gradle") {
+        return Ok(Builder::Gradle);
+    }
+    if check_files_exists("build.json") {
+        return Ok(Builder::Buildj);
+    }
+
+    Ok(Builder::Unknown)
+}
+
+pub fn get_work_dir(opt_current_dir: &Option<String>) -> XResult<String> {
+    match opt_current_dir {
+        Some(dir) => Ok(dir.clone()), None => match env::current_dir() {
+            Ok(dir) =>  match dir.as_path().to_str() {
+                Some(dir) => Ok(dir.into()), None => Err(rust_util::new_box_error("Error in get current dir!")),
+            },
+            Err(e) => Err(rust_util::new_box_error(&format!("Error in get current dir: {}", e))),
+        },
+    }
+}

src/docker_util.rs

@@ -1,6 +1,8 @@
 use std::process::Command;
 use rust_util::XResult;
 use rust_util::util_cmd;
+use crate::build_util;
+use crate::build_util::Builder;
 
 const DOCKER_CMD: &str = "docker";
 
@@ -48,27 +50,29 @@ impl DockerCmd {
             self.docker_run_gid.unwrap_or_else(|| users::get_current_gid() as u32),
         ));
         cmd.arg("-v");
-        cmd.arg(&format!("{}:/usr/src/app", match self.docker_current_dir {
-            Some(dir) => dir, None => match std::env::current_dir() {
-                Ok(dir) =>  match dir.as_path().to_str() {
-                    Some(dir) => dir.into(), None => return Err(rust_util::new_box_error("Error in get current dir!")),
-                },
-                Err(e) => return Err(rust_util::new_box_error(&format!("Error in get current dir: {}", e))),
-            },
-        }));
+        cmd.arg(&format!("{}:/usr/src/app", build_util::get_work_dir(&self.docker_current_dir)?));
         cmd.arg("-w");
         cmd.arg("/usr/src/app");
         cmd.arg(&self.docker_name);
+
+        let builder = Builder::from(&self.docker_current_dir)?;
+        let builder_name = match builder.get_name() {
+            Some(n) => n, None => {
+                warning!("Unknown builder, use default: cargo");
+                "cargo".into() // default use cargo?
+            },
+        };
+
         let mut cmds_iter = cmds.iter();
         if let Some(cmd0) = cmds_iter.next() {
             if cmd0.starts_with(":") {
                 cmd.arg(&cmd0.chars().skip(1).collect::<String>());
             } else {
-                cmd.arg("cargo");
+                cmd.arg(&builder_name);
                 cmd.arg(&cmd0);
             }
         } else {
-            cmd.arg("cargo");
+            cmd.arg(&builder_name);
         }
         cmds_iter.for_each(|c| { cmd.arg(c); });
         information!("Docker cmd exec: {:?}", cmd);

src/main.rs

@@ -1,14 +1,16 @@
 #[macro_use]
 extern crate rust_util;
 
+mod build_util;
 mod docker_util;
 
+use std::env;
 pub use docker_util::DockerCmd;
 
 fn main() {
     information!("dockerbuild v0.1");
 
-    let args_iter = std::env::args().skip(1);
+    let args_iter = env::args().skip(1);
     let args = args_iter.map(|a| a.to_owned()).collect::<Vec<_>>();
     DockerCmd::new("rust:1.47").exec(&args).unwrap();
 }