Implemented extraction for zip/tar/tar.zstd

Author: Heliozoa

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

@@ -147,7 +147,7 @@ test("extracts project", async () => {
 
   const dir = await tempdir();
   expect(fs.existsSync([dir, "setup.py"].join("/"))).toBeFalsy();
-  tmc.extractProject("jest/python-exercise.zip", dir);
+  tmc.extractProject("jest/python-exercise.zip", dir, "zip");
   expect(fs.existsSync([dir, "setup.py"].join("/"))).toBeTruthy();
 });
 

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

@@ -110,15 +110,20 @@ fn compress_project(mut cx: FunctionContext) -> JsResult<JsValue> {
 }
 
 fn extract_project(mut cx: FunctionContext) -> JsResult<JsValue> {
-    parse_args!(cx, archive_path: PathBuf, output_path: PathBuf);
+    parse_args!(
+        cx,
+        archive_path: PathBuf,
+        output_path: PathBuf,
+        compression: Compression
+    );
 
     let mut archive =
         file_util::open_file_lock(archive_path).map_err(|e| convert_err(&mut cx, e))?;
     let mut guard = archive.write().expect("failed to lock file");
     let mut data = vec![];
     guard.read_to_end(&mut data).expect("failed to read data");
 
-    let res = tmc_langs::extract_project(Cursor::new(data), &output_path, false);
+    let res = tmc_langs::extract_project(Cursor::new(data), &output_path, compression, false);
     convert_res(&mut cx, res)
 }
 

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

@@ -15,7 +15,7 @@ export function checkstyle(
 ): types.StyleValidationResult | null;
 export function clean(exercisePath: string): void;
 export function compressProject(exercisePath: string, outputPath: string, compression: Compression, naive: boolean): void;
-export function extractProject(archivePath: string, outputPath: string): void;
+export function extractProject(archivePath: string, outputPath: string, compression: Compression): void;
 export function fastAvailablePoints(exercisePath: string): Array<string>;
 export function findExercises(exercisePath: string): Array<string>;
 export function getExercisePackagingConfiguration(

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 Compression = "Tar" | "Zip" | "TarZstd";
+export type Compression = "tar" | "zip" | "zstd";
 
 export interface RefreshData { new_cache_path: string, course_options: object, exercises: Array<RefreshExercise>, }
 

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

@@ -42,8 +42,8 @@ export class Tmc {
     return tmc.compressProject(exercisePath, outputPath, compression, naive);
   }
 
-  extractProject(archivePath: string, outputPath: string): void {
-    return tmc.extractProject(archivePath, outputPath);
+  extractProject(archivePath: string, outputPath: string, compression: Compression): void {
+    return tmc.extractProject(archivePath, outputPath, compression);
   }
 
   fastAvailablePoints(exercisePath: string): Array<string> {

tmc-client/src/tmc_client.rs

@@ -586,7 +586,7 @@ impl TmcClient {
 
         let mut buf = vec![];
         api_v8::core::download_exercise_solution(self, exercise_id, &mut buf)?;
-        tmc_langs_plugins::extract_project(Cursor::new(buf), target, false)?;
+        tmc_langs_plugins::extract_project(Cursor::new(buf), target, Compression::Zip, false)?;
         Ok(())
     }
 

tmc-langs-cli/src/lib.rs

@@ -247,7 +247,7 @@ fn run_app(matches: Opt) -> Result<()> {
             let mut data = vec![];
             guard.read_to_end(&mut data)?;
 
-            tmc_langs::extract_project(Cursor::new(data), &output_path, true)?;
+            tmc_langs::extract_project(Cursor::new(data), &output_path, compression, true)?;
 
             OutputKind::finished(format!(
                 "extracted project from {} to {}",

tmc-langs-framework/src/archive.rs

@@ -18,6 +18,14 @@ pub enum Archive<T: Read + Seek> {
 }
 
 impl<T: Read + Seek> Archive<T> {
+    pub fn new(archive: T, compression: Compression) -> Result<Self, TmcError> {
+        match compression {
+            Compression::Tar => Ok(Self::tar(archive)),
+            Compression::TarZstd => Self::tar_zstd(archive),
+            Compression::Zip => Self::zip(archive),
+        }
+    }
+
     pub fn tar(archive: T) -> Self {
         let archive = tar::Archive::new(archive);
         Self::Tar(archive)

tmc-langs-framework/src/plugin.rs

@@ -7,7 +7,7 @@ use crate::{
     },
     error::TmcError,
     policy::StudentFilePolicy,
-    Archive, TmcProjectYml,
+    Archive, Compression, TmcProjectYml,
 };
 pub use isolang::Language;
 use nom::{branch, bytes, character, combinator, error::VerboseError, multi, sequence, IResult};
@@ -99,22 +99,23 @@ pub trait LanguagePlugin {
     fn extract_project(
         compressed_project: impl std::io::Read + std::io::Seek,
         target_location: &Path,
+        compression: Compression,
         clean: bool,
     ) -> Result<(), TmcError> {
         log::debug!("Unzipping to {}", target_location.display());
 
-        let mut zip_archive = Archive::zip(compressed_project)?;
+        let mut archive = Archive::new(compressed_project, compression)?;
 
         // find the exercise root directory inside the archive
-        let project_dir = Self::find_project_dir_in_archive(&mut zip_archive)?;
+        let project_dir = Self::find_project_dir_in_archive(&mut archive)?;
         log::debug!("Project dir in zip: {}", project_dir.display());
 
         // extract config file if any
         let tmc_project_yml_path = project_dir.join(".tmcproject.yml");
         let tmc_project_yml_path_s = tmc_project_yml_path
             .to_str()
             .ok_or_else(|| TmcError::ProjectDirInvalidUtf8(project_dir.clone()))?;
-        if let Ok(mut file) = zip_archive.by_path(tmc_project_yml_path_s) {
+        if let Ok(mut file) = archive.by_path(tmc_project_yml_path_s) {
             let target_path = target_location.join(".tmcproject.yml");
             file_util::read_to_file(&mut file, target_path)?;
         }
@@ -123,7 +124,7 @@ pub trait LanguagePlugin {
         // used to clean non-student files not in the zip later
         let mut files_from_zip = HashSet::new();
 
-        let mut iter = zip_archive.iter()?;
+        let mut iter = archive.iter()?;
         loop {
             let next = iter.with_next::<(), _>(|mut file| {
                 let file_path = file.path()?;
@@ -860,6 +861,7 @@ def f():
         MockPlugin::extract_project(
             std::io::Cursor::new(zip),
             &temp.path().join("extracted"),
+            Compression::Zip,
             false,
         )
         .unwrap();
@@ -893,6 +895,7 @@ def f():
         MockPlugin::extract_project(
             std::io::Cursor::new(zip),
             &temp.path().join("extracted"),
+            Compression::Zip,
             false,
         )
         .unwrap();
@@ -934,6 +937,7 @@ force_update:
         MockPlugin::extract_project(
             std::io::Cursor::new(zip),
             &temp.path().join("extracted"),
+            Compression::Zip,
             false,
         )
         .unwrap();
@@ -970,6 +974,7 @@ force_update:
         MockPlugin::extract_project(
             std::io::Cursor::new(zip),
             &temp.path().join("extracted"),
+            Compression::Zip,
             false,
         )
         .unwrap();
@@ -999,6 +1004,7 @@ force_update:
         MockPlugin::extract_project(
             std::io::Cursor::new(zip),
             &temp.path().join("extracted"),
+            Compression::Zip,
             true,
         )
         .unwrap();

tmc-langs-plugins/src/lib.rs

@@ -27,10 +27,11 @@ pub use tmc_langs_r::RPlugin;
 pub fn extract_project(
     compressed_project: impl std::io::Read + std::io::Seek,
     target_location: &Path,
+    compression: Compression,
     clean: bool,
 ) -> Result<(), PluginError> {
     if let Ok(plugin) = get_language_plugin(target_location) {
-        plugin.extract_project(compressed_project, target_location, clean)?;
+        plugin.extract_project(compressed_project, target_location, compression, clean)?;
     } else {
         log::debug!(
             "no matching language plugin found for {}, overwriting",
@@ -98,7 +99,7 @@ pub fn compress_project(path: &Path, compression: Compression) -> Result<Vec<u8>
 #[impl_enum::with_methods(
     pub fn clean(&self, path: &Path) -> Result<(), TmcError> {}
     pub fn get_exercise_packaging_configuration(config: TmcProjectYml) -> Result<ExercisePackagingConfiguration, TmcError> {}
-    pub fn extract_project(compressed_project: impl std::io::Read + std::io::Seek, target_location: &Path, clean: bool) -> Result<(), TmcError> {}
+    pub fn extract_project(compressed_project: impl std::io::Read + std::io::Seek, target_location: &Path, compression: Compression, clean: bool) -> Result<(), TmcError> {}
     pub fn extract_student_files(compressed_project: impl std::io::Read + std::io::Seek, target_location: &Path) -> Result<(), TmcError> {}
     pub fn scan_exercise(&self, path: &Path, exercise_name: String) -> Result<ExerciseDesc, TmcError> {}
     pub fn run_tests(&self, path: &Path) -> Result<RunResult, TmcError> {}