Make the compiler use local source code

Now the source code is compressed and statically linked into the binary, so there is no need to git clone it from github anymore, both removing version issues and the git dependency.

.gitignore

@@ -1,4 +1,4 @@
 target/
 test/
 Cargo.lock
-
+code.tar.gz

compiled_voila/Cargo.toml

@@ -4,4 +4,4 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-voila = {path = "../voila"}
+voila = {path = "../voila"}

compiled_voila/src/main.rs

@@ -1,4 +1,8 @@
 fn main() {
+    // the use of the `env!()` macro instead of
+    // its `option_env!()` counterpart is on purpose,
+    // so if the data needed to run is not provided, a compile-time
+    // error will be thrown instead of a runtime one.
     if let Err(ref e) = voila::exec(
         str_to_vec_u8(env!("v_code")).into(), // into() automatically deserializes the data
         std::path::PathBuf::from(env!("v_path")),

voila/Cargo.toml

@@ -27,8 +27,8 @@ keywords = [
 
 [dependencies]
 md5 = "0.7.0"
-sha2 = "0.10.0"
-sha-1 = "0.10.0"
+sha2 = "0.9.5"
+sha-1 = "0.9.7"
 walkdir = "2.3.2"
 regex = "1.5.4"
 structopt = "0.3.23"
@@ -51,6 +51,10 @@ serde = "1.0.130"
 serde_derive = "1.0.130"
 bincode = "1.3.3"
 
+[build-dependencies]
+tar = "0.4.37"
+flate2 = "1.0.21"
+
 [dev-dependencies]
 criterion = "0.3.5"
 

voila/build.rs

@@ -0,0 +1,27 @@
+use flate2::write::GzEncoder;
+use flate2::Compression;
+use std::env::current_dir;
+use std::fs::File;
+
+const COMPILE_ASSETS: [&str; 4] = ["voila", "compiled_voila", "Cargo.toml", "Cargo.lock"];
+
+fn main() {
+    let src = &current_dir().expect("Can't open current directory");
+    let src = src.parent().unwrap();
+    let dest = File::create(format!("{}/code.tar.gz", src.to_str().unwrap()))
+        .expect("Can't write to current directory");
+    println!("{}/code.tar.gz", src.to_str().unwrap());
+    let encoder = GzEncoder::new(dest, Compression::default());
+    let mut tar = tar::Builder::new(encoder);
+    for a in COMPILE_ASSETS {
+        let p = src.join(a);
+        if p.is_dir() {
+            tar.append_dir_all(a, p)
+                .expect("Can't read current directory");
+        } else {
+            tar.append_path_with_name(p, a)
+                .expect("Can't read current directory");
+        }
+    }
+    tar.finish().unwrap();
+}

voila/src/ast/call.rs

@@ -410,10 +410,11 @@ fn gzc(source: &str, dest: &str) -> Result<(), io::Error> {
     let mut tar = tar::Builder::new(encoder);
     let source = PathBuf::from(source);
     if source.is_dir() {
-        tar.append_dir_all(source.clone(), source)
+        tar.append_dir_all(source.clone(), source)?;
     } else {
-        tar.append_path(source)
+        tar.append_path(source)?;
     }
+    tar.finish()
 }
 
 fn gzd(source: &str, dest: &str) -> Result<(), io::Error> {

voila/src/ast/lookup.rs

@@ -132,6 +132,7 @@ trait Specifier<T: Sized, const O: usize> {
     fn detect(source: &str) -> Option<T>;
 }
 
+#[allow(clippy::enum_variant_names)]
 #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum SizeLabel {
     TeraBytes,

voila/src/ast/script.rs

@@ -45,9 +45,3 @@ pub fn run_script(
     //     });
     // }
 }
-
-impl<'source> From<Vec<u8>> for Script<'source> {
-    fn from(s: Vec<u8>) -> Self {
-        bincode::deserialize(&s[..]).unwrap()
-    }
-}

voila/src/bytecode.rs

@@ -0,0 +1,15 @@
+use crate::ast::Script;
+
+pub type VoilaByteCode = Vec<u8>;
+
+impl<'source> From<Script<'source>> for VoilaByteCode {
+    fn from(code: Script<'source>) -> Self {
+        bincode::serialize(&code).unwrap()
+    }
+}
+
+impl<'source> From<VoilaByteCode> for Script<'source> {
+    fn from(s: VoilaByteCode) -> Self {
+        bincode::deserialize(&s[..]).unwrap()
+    }
+}

voila/src/compiler.rs

@@ -1,43 +1,36 @@
+use flate2::read::GzDecoder;
 use std::env;
 use std::fs;
 use std::path::Path;
 use std::process;
+use tar::Archive;
 
-/// Compiles with cargo nightly a crate in a given path
-/// providing variables needed to run voila (e.g script's code)
-/// leaving the compiled binary in the current directory.
-pub fn compile(vars: [&str; 3]) -> Result<(), &str> {
-    // save current dir
-    let pwd = env::current_dir().unwrap();
+// Error messages
+const COMPILER_ERR_MSG: &str = "Could not compile. Make sure Cargo (a wrapper over rust's compiler) is installed, it's in your PATH and the nightly toolchain is installed:\nhttps://www.rust-lang.org/tools/install";
+const TEMPDIR_ERR_MSG: &str = "Can't write to temporary directory";
+const ENV_READ_ERR_MSG: &str = "Can't access current directory";
+const ENV_WRITE_ERR_MSG: &str = "Can't change environment";
 
-    // set git clone path
+/// Embeds a Voila Script into a binary through
+/// the `compiled_voila` crate. The source is
+/// statically linked into the binary.
+pub fn compile(vars: [&str; 3]) -> Result<(), &str> {
+    let source = include_bytes!("../../code.tar.gz").as_ref();
+    let pwd = env::current_dir().map_err(|_| ENV_READ_ERR_MSG)?;
     let target_dir = &get_target_dir();
+    let mut archive = Archive::new(GzDecoder::new(source));
 
-    // delete target dir (if exists)
+    // prepare target dir
     if Path::new(target_dir).exists() {
-        fs::remove_dir_all(target_dir).unwrap();
-    }
-
-    // clone repo
-    const GIT_ERR_MSG: &str = "Could not download required files to compile the code. Make sure git is installed and in your PATH:\nhttps://git-scm.com/";
-    let git_exit_status = process::Command::new("git")
-        .arg("clone")
-        .arg("https://github.com/Alonely0/Voila.git")
-        .arg(target_dir)
-        .status()
-        .map_err(|_| GIT_ERR_MSG)?
-        .code()
-        .unwrap_or(0);
-
-    if git_exit_status > 0 {
-        return Err(GIT_ERR_MSG);
+        fs::remove_dir_all(target_dir).map_err(|_| TEMPDIR_ERR_MSG)?;
     }
+    fs::create_dir_all(target_dir).map_err(|_| TEMPDIR_ERR_MSG)?;
+    archive.unpack(target_dir).map_err(|_| TEMPDIR_ERR_MSG)?;
 
     // set dir so cargo knows where to run
-    env::set_current_dir(target_dir).unwrap();
+    env::set_current_dir(target_dir).map_err(|_| ENV_WRITE_ERR_MSG)?;
 
     // launch compiler & get exit code
-    const COMPILER_ERR_MSG: &str = "Could not compile. Make sure Cargo (a wrapper over rust's compiler) is installed, it's in your PATH and the nightly toolchain is installed:\nhttps://www.rust-lang.org/tools/install";
     let compiler_exit_status = process::Command::new("cargo")
         .env("v_code", vars[0])
         .env("v_path", vars[1])
@@ -54,10 +47,10 @@ pub fn compile(vars: [&str; 3]) -> Result<(), &str> {
         .unwrap_or(0);
 
     // restore to the actual current directory
-    env::set_current_dir(pwd).unwrap();
+    env::set_current_dir(pwd).map_err(|_| ENV_WRITE_ERR_MSG)?;
 
     // remove temporary files
-    fs::remove_dir_all(target_dir).unwrap();
+    // fs::remove_dir_all(target_dir).map_err(|_| "Can't write to temporary directory")?;
 
     if compiler_exit_status > 0 {
         Err(COMPILER_ERR_MSG)
@@ -66,7 +59,7 @@ pub fn compile(vars: [&str; 3]) -> Result<(), &str> {
     }
 }
 
-fn get_target_dir() -> String {
+pub fn get_target_dir() -> String {
     #[cfg(unix)]
     return "/tmp/Voila".to_string();
     #[cfg(windows)]

voila/src/lib.rs

@@ -1,5 +1,4 @@
 #![forbid(unsafe_code)] // unsafe code makes ferris get nervous
-#![feature(format_args_capture)]
 #![feature(once_cell)]
 #![feature(decl_macro)]
 #![feature(never_type)]
@@ -8,6 +7,7 @@
 use std::error::Error;
 
 mod ast;
+mod bytecode;
 mod cli;
 mod error;
 mod interpreter;

voila/src/main.rs

@@ -1,5 +1,4 @@
 #![forbid(unsafe_code)] // unsafe code makes ferris get nervous
-#![feature(format_args_capture)]
 #![feature(decl_macro)]
 #![allow(clippy::upper_case_acronyms)]