Add pre-commit hooks for linting & tests

.rusty-hook.toml

@@ -0,0 +1,5 @@
+[hooks]
+pre-commit = "cargo fmt && cargo clippy -- -Dwarnings && cargo test"
+
+[logging]
+verbose = true

Cargo.toml

@@ -6,6 +6,9 @@ authors = ["Michael Flaherty (Headline#9999)"]
 edition = "2018"
 build = "src/build.rs"
 
+[dev-dependencies]
+rusty-hook = "0.11.2"
+
 [dependencies]
 tokio = { version = "1", features = ["full"] }
 reqwest = { version = "0.11" }

src/apis/mod.rs

@@ -1 +1 @@
-pub mod dbl;
+pub mod dbl;

src/boilerplate/c.rs

@@ -2,33 +2,27 @@ use crate::boilerplate::generator::BoilerPlateGenerator;
 use crate::utls::constants::C_LIKE_MAIN_REGEX;
 
 pub struct CGenerator {
-    input : String
+    input: String,
 }
 
 impl BoilerPlateGenerator for CGenerator {
     fn new(input: &str) -> Self {
         let mut formated = input.to_string();
-        formated = formated.replace(";", ";\n"); // separate lines by ;
+        formated = formated.replace(';', ";\n"); // separate lines by ;
 
-        Self {
-            input : formated
-        }
+        Self { input: formated }
     }
 
     fn generate(&self) -> String {
         let mut main_body = String::default();
         let mut header = String::default();
 
-        let mut lines = self.input.split("\n");
-        while let Some(line) = lines.next() {
+        let lines = self.input.split('\n');
+        for line in lines {
             let trimmed = line.trim();
-            if trimmed.starts_with("using") {
-                header.push_str(&format!("{}\n", trimmed));
-            }
-            else if trimmed.starts_with("#i") {
+            if trimmed.starts_with("using") || trimmed.starts_with("#i") {
                 header.push_str(&format!("{}\n", trimmed));
-            }
-            else {
+            } else {
                 main_body.push_str(&format!("{}\n", trimmed))
             }
         }
@@ -41,10 +35,10 @@ impl BoilerPlateGenerator for CGenerator {
 
     fn needs_boilerplate(&self) -> bool {
         for m in C_LIKE_MAIN_REGEX.captures_iter(&self.input) {
-            if let Some(_) = m.name("main") {
+            if m.name("main").is_some() {
                 return false;
             }
         }
-        return true;
+        true
     }
-}
+}

src/boilerplate/cpp.rs

@@ -2,33 +2,27 @@ use crate::boilerplate::generator::BoilerPlateGenerator;
 use crate::utls::constants::C_LIKE_MAIN_REGEX;
 
 pub struct CppGenerator {
-    input : String
+    input: String,
 }
 
 impl BoilerPlateGenerator for CppGenerator {
     fn new(input: &str) -> Self {
         let mut formated = input.to_string();
-        formated = formated.replace(";", ";\n"); // separate lines by ;
+        formated = formated.replace(';', ";\n"); // separate lines by ;
 
-        Self {
-            input : formated
-        }
+        Self { input: formated }
     }
 
     fn generate(&self) -> String {
         let mut main_body = String::default();
         let mut header = String::default();
 
-        let mut lines = self.input.split("\n");
-        while let Some(line) = lines.next() {
+        let lines = self.input.split('\n');
+        for line in lines {
             let trimmed = line.trim();
-            if trimmed.starts_with("using") {
-                header.push_str(&format!("{}\n", trimmed));
-            }
-            else if trimmed.starts_with("#i") {
+            if trimmed.starts_with("using") || trimmed.starts_with("#i") {
                 header.push_str(&format!("{}\n", trimmed));
-            }
-            else {
+            } else {
                 main_body.push_str(&format!("{}\n", trimmed))
             }
         }
@@ -42,10 +36,10 @@ impl BoilerPlateGenerator for CppGenerator {
 
     fn needs_boilerplate(&self) -> bool {
         for m in C_LIKE_MAIN_REGEX.captures_iter(&self.input) {
-            if let Some(_) = m.name("main") {
+            if m.name("main").is_some() {
                 return false;
             }
         }
-        return true;
+        true
     }
-}
+}

src/boilerplate/csharp.rs

@@ -2,30 +2,27 @@ use crate::boilerplate::generator::BoilerPlateGenerator;
 use crate::utls::constants::CSHARP_MAIN_REGEX;
 
 pub struct CSharpGenerator {
-    input : String
+    input: String,
 }
 
 impl BoilerPlateGenerator for CSharpGenerator {
     fn new(input: &str) -> Self {
         let mut formated = input.to_string();
-        formated = formated.replace(";", ";\n"); // separate lines by ;
+        formated = formated.replace(';', ";\n"); // separate lines by ;
 
-        Self {
-            input : formated
-        }
+        Self { input: formated }
     }
 
     fn generate(&self) -> String {
         let mut main_body = String::default();
         let mut header = String::default();
 
-        let mut lines = self.input.split("\n");
-        while let Some(line) = lines.next() {
+        let lines = self.input.split('\n');
+        for line in lines {
             let trimmed = line.trim();
             if trimmed.starts_with("using") {
                 header.push_str(&format!("{}\n", trimmed));
-            }
-            else {
+            } else {
                 main_body.push_str(&format!("{}\n", trimmed))
             }
         }
@@ -34,15 +31,18 @@ impl BoilerPlateGenerator for CSharpGenerator {
         if header.is_empty() {
             header.push_str("using System;");
         }
-        format!("{}\nnamespace Main{{\nclass Program {{\n static void Main(string[] args) {{\n{}}}}}}}", header, main_body)
+        format!(
+            "{}\nnamespace Main{{\nclass Program {{\n static void Main(string[] args) {{\n{}}}}}}}",
+            header, main_body
+        )
     }
 
     fn needs_boilerplate(&self) -> bool {
         for m in CSHARP_MAIN_REGEX.captures_iter(&self.input) {
-            if let Some(_) = m.name("main") {
+            if m.name("main").is_some() {
                 return false;
             }
         }
-        return true;
+        true
     }
-}
+}

src/boilerplate/generator.rs

@@ -4,20 +4,26 @@ use crate::boilerplate::csharp::CSharpGenerator;
 use crate::boilerplate::java::JavaGenerator;
 
 pub trait BoilerPlateGenerator {
-    fn new(input : &str) -> Self where Self: Sized;
+    fn new(input: &str) -> Self
+    where
+        Self: Sized;
     fn generate(&self) -> String;
     fn needs_boilerplate(&self) -> bool;
 }
 
-pub struct BoilerPlate<T: ?Sized> where T: BoilerPlateGenerator {
-    generator : Box<T>
+pub struct BoilerPlate<T: ?Sized>
+where
+    T: BoilerPlateGenerator,
+{
+    generator: Box<T>,
 }
 
-impl<T: ?Sized> BoilerPlate<T> where T: BoilerPlateGenerator{
-    pub fn new(generator : Box<T>) -> Self {
-        Self {
-            generator
-        }
+impl<T: ?Sized> BoilerPlate<T>
+where
+    T: BoilerPlateGenerator,
+{
+    pub fn new(generator: Box<T>) -> Self {
+        Self { generator }
     }
 
     pub fn generate(&self) -> String {
@@ -44,25 +50,14 @@ impl BoilerPlateGenerator for Null {
     }
 }
 
-pub fn boilerplate_factory(language : &str, code : &str)
-    -> BoilerPlate<dyn BoilerPlateGenerator> {
-    return match language {
-        "c++" => {
-            BoilerPlate::new(Box::new(CppGenerator::new(code)))
-        }
-        "c" => {
-            BoilerPlate::new(Box::new(CGenerator::new(code)))
-        }
-        "java" => {
-            BoilerPlate::new(Box::new(JavaGenerator::new(code)))
-        }
-        "c#" => {
-            BoilerPlate::new(Box::new(CSharpGenerator::new(code)))
-        }
+pub fn boilerplate_factory(language: &str, code: &str) -> BoilerPlate<dyn BoilerPlateGenerator> {
+    match language {
+        "c++" => BoilerPlate::new(Box::new(CppGenerator::new(code))),
+        "c" => BoilerPlate::new(Box::new(CGenerator::new(code))),
+        "java" => BoilerPlate::new(Box::new(JavaGenerator::new(code))),
+        "c#" => BoilerPlate::new(Box::new(CSharpGenerator::new(code))),
         // since all compilations go through this path, we have a Null generator whose
         // needs_boilerplate() always returns false.
-        _ => {
-            BoilerPlate::new(Box::new(Null::new(code)))
-        }
+        _ => BoilerPlate::new(Box::new(Null::new(code))),
     }
-}
+}