implemented prepare-submission

Author: Heliozoa

tmc-langs-cli/src/app.rs

@@ -79,11 +79,37 @@ pub fn create_app() -> App<'static, 'static> {
                 .takes_value(true)))
 
         .subcommand(SubCommand::with_name("prepare-submission")
-            .about("UNIMPLEMENTED. Prepares from submission and solution project for which the tests can be run in sandbox.")
+            .about("Prepares from submission and solution project for which the tests can be run in sandbox.")
             .arg(Arg::with_name("submission-path")
                 .help("Path to the zip archive to be submitted.")
                 .long("submission-path")
                 .required(true)
+                .takes_value(true))
+            .arg(Arg::with_name("output-path")
+                .help("Path to the resulting archive.")
+                .long("output-path")
+                .required(true)
+                .takes_value(true))
+            .arg(Arg::with_name("tmc-param")
+                .help("A key-value pair in the form key=value to be written into .tmcparams. If multiple pairs with the same key are given, the values are interpreted as an array.")
+                .long("tmc-param")
+                .takes_value(true)
+                .multiple(true))
+            .arg(Arg::with_name("clone-path")
+                .help("Path to exercise's clone path, where the unmodified test files will be copied from.")
+                .long("clone-path")
+                .takes_value(true)
+                .required(true))
+            .arg(Arg::with_name("output-zip")
+                .help("Packages the submission into a zip archive instead of a tar.")
+                .long("output-zip"))
+            .arg(Arg::with_name("top-level-dir-name")
+                .help("If given, the contents in the resulting archive will be nested inside a directory with this name.")
+                .long("top-level-dir-name")
+                .takes_value(true))
+            .arg(Arg::with_name("stub-zip-path")
+                .help("If given, the tests will be copied from the stub zip instead, effectively ignoring hidden tests.")
+                .long("stub-zip-path")
                 .takes_value(true)))
 
         .subcommand(SubCommand::with_name("run-tests")

tmc-langs-cli/src/main.rs

@@ -20,7 +20,10 @@ use tmc_langs_core::oauth2::{
 };
 use tmc_langs_core::{FeedbackAnswer, TmcCore, Token};
 use tmc_langs_framework::io::submission_processing;
-use tmc_langs_util::{task_executor, Language};
+use tmc_langs_util::{
+    task_executor::{self, TmcParams},
+    Language,
+};
 use url::Url;
 use walkdir::WalkDir;
 
@@ -132,12 +135,62 @@ fn run() -> Result<()> {
                 exercise_path.display(),
             )
         })?;
-    } else if let Some(_matches) = matches.subcommand_matches("prepare-submission") {
-        Error::with_description(
-            "This command is unimplemented.",
-            ErrorKind::InvalidSubcommand,
-        )
-        .exit();
+    } else if let Some(matches) = matches.subcommand_matches("prepare-submission") {
+        let submission_path = matches.value_of("submission-path").unwrap();
+        let submission_path = dbg!(Path::new(submission_path));
+
+        let output_path = matches.value_of("output-path").unwrap();
+        let output_path = dbg!(Path::new(output_path));
+
+        let tmc_params_values = matches.values_of("tmc-param").unwrap_or_default();
+        let mut tmc_params_grouped = HashMap::new();
+        for value in tmc_params_values {
+            let params: Vec<_> = value.split('=').collect();
+            if params.len() != 2 {
+                Error::with_description(
+                    "tmc-param values should contain a single '=' as a delimiter.",
+                    ErrorKind::ValueValidation,
+                )
+                .exit();
+            }
+            let key = params[0];
+            let value = params[1];
+            let entry = tmc_params_grouped.entry(key).or_insert_with(Vec::new);
+            entry.push(value);
+        }
+        let mut tmc_params = TmcParams::new();
+        for (key, values) in tmc_params_grouped {
+            if values.len() == 1 {
+                tmc_params
+                    .insert_string(key, values[0])
+                    .context("invalid tmc-param key-value pair")?;
+            } else {
+                tmc_params
+                    .insert_array(key, values)
+                    .context("invalid tmc-param key-value pair")?;
+            }
+        }
+
+        let clone_path = matches.value_of("clone-path").unwrap();
+        let clone_path = dbg!(Path::new(clone_path));
+
+        let output_zip = dbg!(matches.is_present("output-zip"));
+
+        let top_level_dir_name = matches.value_of("top-level-dir-name");
+        let top_level_dir_name = top_level_dir_name.map(str::to_string);
+
+        let stub_zip_path = matches.value_of("stub-zip-path");
+        let stub_zip_path = stub_zip_path.map(Path::new);
+
+        task_executor::prepare_submission(
+            submission_path,
+            output_path,
+            top_level_dir_name,
+            tmc_params,
+            clone_path,
+            stub_zip_path,
+            output_zip,
+        )?;
     } else if let Some(matches) = matches.subcommand_matches("run-tests") {
         let exercise_path = matches.value_of("exercise-path").unwrap();
         let exercise_path = Path::new(exercise_path);

tmc-langs-framework/src/error.rs

@@ -4,6 +4,7 @@ use std::path::PathBuf;
 use std::time::Duration;
 use thiserror::Error;
 
+// todo: make util error type and move variants there
 #[derive(Error, Debug)]
 pub enum TmcError {
     // IO
@@ -17,10 +18,14 @@ pub enum TmcError {
     CreateDir(PathBuf, #[source] std::io::Error),
     #[error("Failed to remove dir at {0}")]
     RemoveDir(PathBuf, #[source] std::io::Error),
+    #[error("Failed to create temporary directory")]
+    TempDir(#[source] std::io::Error),
     #[error("Failed to rename {0} to {1}")]
     Rename(PathBuf, PathBuf, #[source] std::io::Error),
     #[error("Failed to write to {0}")]
     Write(PathBuf, #[source] std::io::Error),
+    #[error("Failed to read zip archive at {0}")]
+    ZipRead(PathBuf, #[source] std::io::Error),
     #[error("Error appending to tar")]
     TarAppend(#[source] std::io::Error),
     #[error("Error finishing tar")]
@@ -37,6 +42,10 @@ pub enum TmcError {
     Canonicalize(PathBuf, #[source] std::io::Error),
     #[error("Error occurred in a child process")]
     Process(#[source] std::io::Error),
+    #[error("Failed to set permissions for {0}")]
+    SetPermissions(PathBuf, #[source] std::io::Error),
+    #[error("Invalid parameter value: {0}")]
+    InvalidParam(String),
 
     #[error("Path {0} contained invalid UTF8")]
     UTF8(PathBuf),
@@ -62,4 +71,6 @@ pub enum TmcError {
     YamlDeserialization(#[from] serde_yaml::Error),
     #[error(transparent)]
     ZipError(#[from] zip::ZipError),
+    #[error(transparent)]
+    WalkDir(#[from] walkdir::Error),
 }

tmc-langs-java/src/ant.rs

@@ -9,7 +9,7 @@ use policy::AntStudentFilePolicy;
 use std::env;
 use std::fs::{self, File};
 use std::io::Write;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::time::Duration;
 use tmc_langs_framework::{
@@ -145,6 +145,14 @@ impl LanguagePlugin for AntPlugin {
             .into())
         }
     }
+
+    fn get_default_student_file_paths(&self) -> Vec<PathBuf> {
+        vec![PathBuf::from("src/main")]
+    }
+
+    fn get_default_exercise_file_paths(&self) -> Vec<PathBuf> {
+        vec![PathBuf::from("src/test")]
+    }
 }
 
 impl JavaPlugin for AntPlugin {

tmc-langs-java/src/error.rs

@@ -42,6 +42,8 @@ pub enum JavaError {
     FileCopy(PathBuf, PathBuf, #[source] std::io::Error),
     #[error("Failed to find cache directory")]
     CacheDir,
+    #[error("Failed to compile")]
+    Compilation(Vec<u8>),
 
     #[error(transparent)]
     Json(#[from] serde_json::Error),

tmc-langs-java/src/maven.rs

@@ -10,7 +10,7 @@ use policy::MavenStudentFilePolicy;
 use std::ffi::OsString;
 use std::fs;
 use std::io::Cursor;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::time::Duration;
 use tar::Archive;
@@ -128,6 +128,14 @@ impl LanguagePlugin for MavenPlugin {
 
         Ok(())
     }
+
+    fn get_default_student_file_paths(&self) -> Vec<PathBuf> {
+        vec![PathBuf::from("src/main")]
+    }
+
+    fn get_default_exercise_file_paths(&self) -> Vec<PathBuf> {
+        vec![PathBuf::from("src/test")]
+    }
 }
 
 impl JavaPlugin for MavenPlugin {

tmc-langs-java/src/plugin.rs

@@ -151,8 +151,10 @@ pub(crate) trait JavaPlugin: LanguagePlugin {
         exercise_name: String,
         compile_result: CompileResult,
     ) -> Result<ExerciseDesc, JavaError> {
-        if !Self::is_exercise_type_correct(path) || !compile_result.status_code.success() {
+        if !Self::is_exercise_type_correct(path) {
             return Err(JavaError::InvalidExercise(path.to_path_buf()));
+        } else if !compile_result.status_code.success() {
+            return Err(JavaError::Compilation(compile_result.stderr));
         }
 
         let mut source_files = vec![];

tmc-langs-util/Cargo.toml

@@ -16,7 +16,9 @@ tmc-langs-r = { path = "../tmc-langs-r" }
 log = "0.4"
 tar = "0.4"
 walkdir = "2"
+tempfile = "3"
+zip = "0.5"
+shellwords = "1"
 
 [dev-dependencies]
 env_logger = "0.7"
-tempfile = "3"

tmc-langs-util/src/lib.rs

@@ -1,6 +1,5 @@
 //! Contains the task executor
 
-mod tar;
 pub mod task_executor;
 
 pub use tmc_langs_abstraction::{Strategy, ValidationResult};

tmc-langs-util/src/task_executor.rs

@@ -1,13 +1,18 @@
 //! Module for calling different tasks of TMC-langs language plug-ins.
 
-use super::{
-    tar, ExerciseDesc, ExercisePackagingConfiguration, RunResult, TmcError, ValidationResult,
-};
+mod file_util;
+mod submission_packaging;
+mod tar_helper;
+
+pub use submission_packaging::TmcParams;
+
+use crate::{ExerciseDesc, ExercisePackagingConfiguration, RunResult, TmcError, ValidationResult};
 use log::info;
 use std::path::{Path, PathBuf};
 use tmc_langs_csharp::CSharpPlugin;
 use tmc_langs_framework::{
-    io::{submission_processing, zip},
+    domain::TmcProjectYml,
+    io,
     plugin::{Language, LanguagePlugin},
     policy::NothingIsStudentFilePolicy,
 };
@@ -23,7 +28,7 @@ pub fn prepare_solutions<'a, I: IntoIterator<Item = &'a PathBuf>>(
     exercise_paths: I,
     dest_root: &Path,
 ) -> Result<(), TmcError> {
-    submission_processing::prepare_solutions(exercise_paths, dest_root)?;
+    io::submission_processing::prepare_solutions(exercise_paths, dest_root)?;
     Ok(())
 }
 
@@ -40,6 +45,28 @@ pub fn prepare_stubs<I: IntoIterator<Item = PathBuf>>(
     Ok(())
 }
 
+/// Takes a submission zip and turns it into a tar suitable for processing
+/// by among other things resetting the test files
+pub fn prepare_submission(
+    zip_path: &Path,
+    target_path: &Path,
+    toplevel_dir_name: Option<String>,
+    tmc_params: TmcParams,
+    clone_path: &Path,
+    stub_zip_path: Option<&Path>,
+    output_zip: bool,
+) -> Result<(), TmcError> {
+    submission_packaging::prepare_submission(
+        zip_path,
+        target_path,
+        toplevel_dir_name,
+        tmc_params,
+        clone_path,
+        stub_zip_path,
+        output_zip,
+    )
+}
+
 /// See `LanguagePlugin::check_code_style`.
 pub fn run_check_code_style(
     path: &Path,
@@ -84,7 +111,7 @@ pub fn extract_project_overwrite(
     compressed_project: &Path,
     target_location: &Path,
 ) -> Result<(), TmcError> {
-    zip::unzip(
+    io::zip::unzip(
         NothingIsStudentFilePolicy {},
         compressed_project,
         target_location,
@@ -112,7 +139,7 @@ pub fn compress_tar_for_submitting(
     tmcrun: &Path,
     target_location: &Path,
 ) -> Result<(), TmcError> {
-    tar::create_tar_from_project(project_dir, tmc_langs, tmcrun, target_location)?;
+    tar_helper::create_tar_from_project(project_dir, tmc_langs, tmcrun, target_location)?;
     Ok(())
 }