Added compression and naive to compression APIs

Author: Heliozoa

bindings/tmc-langs-node/src/bin/generate-bindings.rs

@@ -13,7 +13,7 @@ fn main() {
         // listLocalCourseExercises
         tmc_langs::LocalExercise,
         // prepareSubmission
-        tmc_langs::OutputFormat,
+        tmc_langs::Compression,
         // refreshCourse
         tmc_langs::RefreshData,
         tmc_langs::RefreshExercise,

bindings/tmc-langs-node/src/lib.rs

@@ -13,8 +13,8 @@ use std::{
 };
 use thiserror::Error;
 use tmc_langs::{
-    file_util, ClientError, Credentials, DownloadOrUpdateCourseExercisesResult, FeedbackAnswer,
-    LangsError, Language, NewSubmission, OutputFormat, SubmissionFinished, TmcClient, TmcConfig,
+    file_util, ClientError, Compression, Credentials, DownloadOrUpdateCourseExercisesResult,
+    FeedbackAnswer, LangsError, Language, NewSubmission, SubmissionFinished, TmcClient, TmcConfig,
 };
 
 #[derive(Debug, Error)]
@@ -96,10 +96,15 @@ fn clean(mut cx: FunctionContext) -> JsResult<JsValue> {
 }
 
 fn compress_project(mut cx: FunctionContext) -> JsResult<JsValue> {
-    parse_args!(cx, exercise_path: PathBuf, output_path: PathBuf);
+    parse_args!(
+        cx,
+        exercise_path: PathBuf,
+        output_path: PathBuf,
+        compression: Compression
+    );
     lock!(cx, exercise_path);
 
-    let res = tmc_langs::compress_project_to(&exercise_path, &output_path);
+    let res = tmc_langs::compress_project_to(&exercise_path, &output_path, compression);
     convert_res(&mut cx, res)
 }
 
@@ -188,10 +193,10 @@ fn prepare_submission(mut cx: FunctionContext) -> JsResult<JsValue> {
                 .expect("invalid key-value pair");
         }
     }
-    let output_format = match output_format.as_str() {
-        "Tar" => OutputFormat::Tar,
-        "Zip" => OutputFormat::Zip,
-        "TarZstd" => OutputFormat::TarZstd,
+    let compression = match output_format.as_str() {
+        "Tar" => Compression::Tar,
+        "Zip" => Compression::Zip,
+        "TarZstd" => Compression::TarZstd,
         _ => panic!("unrecognized output format"),
     };
 
@@ -202,7 +207,7 @@ fn prepare_submission(mut cx: FunctionContext) -> JsResult<JsValue> {
         tmc_params,
         &clone_path,
         stub_zip_path.as_deref(),
-        output_format,
+        compression,
     );
     convert_res(&mut cx, res)
 }

bindings/tmc-langs-node/ts/functions.d.ts

@@ -31,7 +31,7 @@ export function prepareSolution(
 ): void;
 export function prepareStub(exercisePath: string, outputPath: string): void;
 export function prepareSubmission(
-  outputFormat: types.OutputFormat,
+  outputFormat: types.Compression,
   clonePath: string,
   outputPath: string,
   stubZipPath: string | null,

bindings/tmc-langs-node/ts/generated.d.ts

@@ -8,7 +8,7 @@ export interface ExercisePackagingConfiguration { student_file_paths: Array<stri
 
 export interface LocalExercise { exercise_slug: string, exercise_path: string, }
 
-export type OutputFormat = "Tar" | "Zip" | "TarZstd";
+export type Compression = "Tar" | "Zip" | "TarZstd";
 
 export interface RefreshData { new_cache_path: string, course_options: object, exercises: Array<RefreshExercise>, }
 

bindings/tmc-langs-node/ts/tmc.ts

@@ -73,7 +73,7 @@ export class Tmc {
   }
 
   prepareSubmission(
-    outputFormat: types.OutputFormat,
+    outputFormat: types.Compression,
     clonePath: string,
     outputPath: string,
     stubZipPath: string | null,

tmc-langs-cli/src/app.rs

@@ -5,11 +5,11 @@ use clap::Parser;
 use schemars::JsonSchema;
 use std::{path::PathBuf, str::FromStr};
 use tmc_langs::{
-    CombinedCourseData, CourseData, CourseDetails, CourseExercise,
+    CombinedCourseData, Compression, CourseData, CourseDetails, CourseExercise,
     DownloadOrUpdateCourseExercisesResult, ExerciseDesc, ExerciseDetails,
-    ExercisePackagingConfiguration, Language, LocalExercise, NewSubmission, Organization,
-    OutputFormat, Review, RunResult, StyleValidationResult, Submission, SubmissionFeedbackResponse,
-    SubmissionFinished, UpdateResult, UpdatedExercise,
+    ExercisePackagingConfiguration, Language, LocalExercise, NewSubmission, Organization, Review,
+    RunResult, StyleValidationResult, Submission, SubmissionFeedbackResponse, SubmissionFinished,
+    UpdateResult, UpdatedExercise,
 };
 // use tmc_langs_util::task_executor::RefreshData;
 
@@ -59,29 +59,41 @@ pub enum Command {
         exercise_path: PathBuf,
     },
 
-    /// Compresses the target exercise into a ZIP. Only includes student files using the student file policy of the exercise's plugin
+    /// Compresses the target exercise. Only includes student files using the student file policy of the exercise's plugin
     #[clap(long_about = SCHEMA_NULL)]
     CompressProject {
         /// Path to the directory where the exercise resides.
         #[clap(long)]
         exercise_path: PathBuf,
-        /// Path to the output ZIP archive. Overwritten if it already exists.
+        /// Path to the output archive. Overwritten if it already exists.
         #[clap(long)]
         output_path: PathBuf,
+        /// Compression algorithm to use.
+        #[clap(long, default_value_t = Compression::Zip)]
+        compression: Compression,
+        /// If set, simply compresses the target directory with all of its files.
+        #[clap(long)]
+        naive: bool,
     },
 
     #[clap(subcommand)]
     Core(Core),
 
-    /// Extracts an exercise from a ZIP archive. If the output-path is a project root, the plugin's student file policy will be used to avoid overwriting student files
+    /// Extracts an exercise from an archive. If the output-path is a project root, the plugin's student file policy will be used to avoid overwriting student files
     #[clap(long_about = SCHEMA_NULL)]
     ExtractProject {
-        /// Path to the ZIP archive.
+        /// Path to the archive.
         #[clap(long)]
         archive_path: PathBuf,
         /// Path to the directory where the archive will be extracted.
         #[clap(long)]
         output_path: PathBuf,
+        /// Compression algorithm used for the archive.
+        #[clap(long, default_value_t = Compression::Zip)]
+        compression: Compression,
+        /// If set, simply extracts the target directory with all of its files.
+        #[clap(long)]
+        naive: bool,
     },
 
     /// Parses @Points notations from an exercise's exercise files and returns the point names found
@@ -144,29 +156,36 @@ pub enum Command {
         output_path: PathBuf,
     },
 
-    /// Takes a submission ZIP archive and turns it into an archive with reset test files, and tmc-params, ready for further processing
+    /// Takes a submission archive and turns it into an archive with reset test files, and tmc-params, ready for further processing
     #[clap(long_about = SCHEMA_NULL)]
     PrepareSubmission {
         /// The output format of the submission archive. Defaults to tar.
-        #[clap(long, default_value = "tar")]
-        output_format: OutputFormatWrapper,
+        #[clap(long, default_value_t = Compression::Tar)]
+        output_format: Compression,
         /// Path to exercise's clone path, where the unmodified test files will be copied from.
         #[clap(long)]
         clone_path: PathBuf,
         /// Path to the resulting archive. Overwritten if it already exists.
         #[clap(long)]
         output_path: PathBuf,
-        /// If given, the tests will be copied from this stub ZIP instead, effectively ignoring hidden tests.
-        #[clap(long)]
-        stub_zip_path: Option<PathBuf>,
-        /// Path to the submission ZIP archive.
+        /// If given, the tests will be copied from this stub instead, effectively ignoring hidden tests.
+        // alias for backwards compatibility
+        #[clap(long, alias = "stub_zip_path")]
+        stub_archive_path: Option<PathBuf>,
+        /// Compression algorithm used for the stub archive.
+        #[clap(long, default_value_t = Compression::Zip)]
+        stub_compression: Compression,
+        /// Path to the submission archive.
         #[clap(long)]
         submission_path: PathBuf,
+        /// Compression algorithm used for the submission.
+        #[clap(long, default_value_t = Compression::Zip)]
+        submission_compression: Compression,
         /// 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 collected into an array.
         #[clap(long)]
         tmc_param: Vec<String>,
-        #[clap(long)]
         /// If given, the contents in the resulting archive will be nested inside a directory with this name.
+        #[clap(long)]
         top_level_dir_name: Option<String>,
     },
 
@@ -549,22 +568,6 @@ impl FromStr for Locale {
     }
 }
 
-pub struct OutputFormatWrapper(pub OutputFormat);
-
-impl FromStr for OutputFormatWrapper {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let format = match s {
-            "tar" => OutputFormat::Tar,
-            "zip" => OutputFormat::Zip,
-            "zstd" => OutputFormat::TarZstd,
-            _ => anyhow::bail!("invalid format"),
-        };
-        Ok(OutputFormatWrapper(format))
-    }
-}
-
 // == utilities for printing the JSON schema of the objects printed to stdout by the CLI ==
 const SCHEMA_NULL: &str = "Result data JSON format: null";
 const SCHEMA_TOKEN: &str = r#"Result data JSON format:

tmc-langs-cli/src/lib.rs

@@ -12,7 +12,7 @@ use self::{
 };
 use crate::app::{Locale, Opt};
 use anyhow::{Context, Result};
-use app::{Command, Core, OutputFormatWrapper, Settings};
+use app::{Command, Core, Settings};
 use clap::{ErrorKind, IntoApp, Parser};
 use serde::Serialize;
 use serde_json::Value;
@@ -217,9 +217,11 @@ fn run_app(matches: Opt) -> Result<()> {
         Command::CompressProject {
             exercise_path,
             output_path,
+            compression,
+            naive,
         } => {
             file_util::lock!(exercise_path);
-            tmc_langs::compress_project_to(&exercise_path, &output_path)?;
+            tmc_langs::compress_project_to(&exercise_path, &output_path, compression)?;
             OutputKind::finished(format!(
                 "compressed project from {} to {}",
                 exercise_path.display(),
@@ -236,6 +238,8 @@ fn run_app(matches: Opt) -> Result<()> {
         Command::ExtractProject {
             archive_path,
             output_path,
+            compression,
+            naive,
         } => {
             let mut archive = file_util::open_file_lock(&archive_path)?;
             let mut guard = archive.write()?;
@@ -356,10 +360,12 @@ fn run_app(matches: Opt) -> Result<()> {
 
         Command::PrepareSubmission {
             clone_path,
-            output_format: OutputFormatWrapper(output_format),
+            output_format,
             output_path,
-            stub_zip_path,
+            stub_archive_path,
+            stub_compression,
             submission_path,
+            submission_compression,
             tmc_param,
             top_level_dir_name,
         } => {
@@ -400,7 +406,7 @@ fn run_app(matches: Opt) -> Result<()> {
                 top_level_dir_name,
                 tmc_params,
                 &clone_path,
-                stub_zip_path.as_deref(),
+                stub_archive_path.as_deref(),
                 output_format,
             )?;
             OutputKind::finished(format!(

tmc-langs-framework/src/lib.rs

@@ -23,3 +23,42 @@ pub use self::{
     tmc_project_yml::{PythonVer, TmcProjectYml},
 };
 pub use nom;
+use serde::Deserialize;
+use std::{fmt::Display, str::FromStr};
+use ts_rs::TS;
+
+/// Supported compression methods.
+#[derive(Debug, Clone, Copy, Deserialize)]
+#[cfg_attr(feature = "ts", derive(TS))]
+pub enum Compression {
+    /// .tar
+    Tar,
+    /// .zip
+    Zip,
+    /// .tar.ztd
+    TarZstd,
+}
+
+impl Display for Compression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Tar => write!(f, "tar"),
+            Self::Zip => write!(f, "zip"),
+            Self::TarZstd => write!(f, "zstd"),
+        }
+    }
+}
+
+impl FromStr for Compression {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let format = match s {
+            "tar" => Compression::Tar,
+            "zip" => Compression::Zip,
+            "zstd" => Compression::TarZstd,
+            _ => return Err("invalid format"),
+        };
+        Ok(format)
+    }
+}

tmc-langs-plugins/src/lib.rs

@@ -9,11 +9,11 @@ use std::{
     path::{Path, PathBuf},
 };
 use tmc_langs_csharp::CSharpPlugin;
+use tmc_langs_framework::{Compression, LanguagePlugin, TmcError, TmcProjectYml};
 pub use tmc_langs_framework::{
     ExerciseDesc, ExercisePackagingConfiguration, Language, NothingIsStudentFilePolicy, RunResult,
     StudentFilePolicy, StyleValidationResult, StyleValidationStrategy,
 };
-use tmc_langs_framework::{LanguagePlugin, TmcError, TmcProjectYml};
 pub use tmc_langs_java::{AntPlugin, MavenPlugin};
 pub use tmc_langs_make::MakePlugin;
 pub use tmc_langs_notests::NoTestsPlugin;
@@ -50,6 +50,14 @@ pub fn extract_project_overwrite(
     Ok(())
 }
 
+pub fn compress_project(path: &Path, compression: Compression) -> Result<Vec<u8>, PluginError> {
+    match compression {
+        Compression::Zip => compress_project_to_zip(path),
+        Compression::Tar => todo!(),
+        Compression::TarZstd => todo!(),
+    }
+}
+
 /// See `LanguagePlugin::compress_project`.
 // TODO: clean up
 pub fn compress_project_to_zip(path: &Path) -> Result<Vec<u8>, PluginError> {

tmc-langs/src/data.rs

@@ -150,15 +150,6 @@ impl Display for ShellString {
     }
 }
 
-/// Output formats for an archive.
-#[derive(Debug)]
-#[cfg_attr(feature = "ts", derive(TS))]
-pub enum OutputFormat {
-    Tar,
-    Zip,
-    TarZstd,
-}
-
 #[derive(Debug)]
 pub enum DownloadResult {
     Success {