conditional clean on extract project

Author: Heliozoa

plugins/python3/src/plugin.rs

@@ -392,6 +392,7 @@ mod test {
 
     #[test]
     fn finds_project_dir_in_zip() {
+        init();
         let file = File::open("tests/data/PythonProject.zip").unwrap();
         let mut zip = ZipArchive::new(file).unwrap();
         let dir = Python3Plugin::find_project_dir_in_zip(&mut zip).unwrap();
@@ -400,9 +401,95 @@ mod test {
 
     #[test]
     fn doesnt_find_project_dir_in_zip() {
+        init();
         let file = File::open("tests/data/PythonWithoutSrc.zip").unwrap();
         let mut zip = ZipArchive::new(file).unwrap();
         let dir = Python3Plugin::find_project_dir_in_zip(&mut zip);
         assert!(dir.is_err());
     }
+
+    #[test]
+    fn extracts_project() {
+        init();
+        let plugin = Python3Plugin::new();
+        let archive = Path::new("tests/data/student_exercise.zip");
+        let temp = tempfile::tempdir().unwrap();
+        assert!(!temp.path().join("src/source.py").exists());
+        plugin.extract_project(archive, temp.path(), false).unwrap();
+        assert!(temp.path().join("src/source.py").exists());
+        assert!(temp.path().join("test/test.py").exists());
+        assert!(temp.path().join("tmc/tmc").exists());
+    }
+
+    #[test]
+    fn extracts_project_over_existing() {
+        init();
+        let plugin = Python3Plugin::new();
+        let archive = Path::new("tests/data/student_exercise.zip");
+        let temp = copy_test("tests/data/student_exercise");
+        assert_eq!(
+            fs::read_to_string(temp.path().join("src/source.py")).unwrap(),
+            "NEW"
+        );
+        assert_eq!(
+            fs::read_to_string(temp.path().join("test/test.py")).unwrap(),
+            "NEW"
+        );
+        assert_eq!(
+            fs::read_to_string(temp.path().join("tmc/tmc")).unwrap(),
+            "NEW"
+        );
+        plugin.extract_project(archive, temp.path(), false).unwrap();
+        assert_eq!(
+            fs::read_to_string(temp.path().join("src/source.py")).unwrap(),
+            "NEW"
+        );
+        assert_eq!(
+            fs::read_to_string(temp.path().join("test/test.py")).unwrap(),
+            "OLD"
+        );
+        assert_eq!(
+            fs::read_to_string(temp.path().join("tmc/tmc")).unwrap(),
+            "OLD"
+        );
+        assert!(temp.path().join("src/new.py").exists());
+        assert!(temp.path().join("test/new.py").exists());
+        assert!(temp.path().join("tmc/new").exists());
+    }
+
+    #[test]
+    fn extracts_project_over_existing_clean() {
+        init();
+        let plugin = Python3Plugin::new();
+        let archive = Path::new("tests/data/student_exercise.zip");
+        let temp = copy_test("tests/data/student_exercise");
+        assert_eq!(
+            fs::read_to_string(temp.path().join("src/source.py")).unwrap(),
+            "NEW"
+        );
+        assert_eq!(
+            fs::read_to_string(temp.path().join("test/test.py")).unwrap(),
+            "NEW"
+        );
+        assert_eq!(
+            fs::read_to_string(temp.path().join("tmc/tmc")).unwrap(),
+            "NEW"
+        );
+        plugin.extract_project(archive, temp.path(), true).unwrap();
+        assert_eq!(
+            fs::read_to_string(temp.path().join("src/source.py")).unwrap(),
+            "NEW"
+        );
+        assert_eq!(
+            fs::read_to_string(temp.path().join("test/test.py")).unwrap(),
+            "OLD"
+        );
+        assert_eq!(
+            fs::read_to_string(temp.path().join("tmc/tmc")).unwrap(),
+            "OLD"
+        );
+        assert!(temp.path().join("src/new.py").exists());
+        assert!(!temp.path().join("test/new.py").exists());
+        assert!(!temp.path().join("tmc/new").exists());
+    }
 }

tmc-langs-cli/src/main.rs

@@ -141,7 +141,7 @@ fn run() -> Result<()> {
             let output_path = matches.value_of("output-path").unwrap();
             let output_path = Path::new(output_path);
 
-            task_executor::extract_project(archive_path, output_path).with_context(|| {
+            task_executor::extract_project(archive_path, output_path, true).with_context(|| {
                 format!("Failed to extract project at {}", output_path.display())
             })?;
 

tmc-langs-core/src/tmc_core.rs

@@ -290,7 +290,7 @@ impl TmcCore {
             progress += step;
 
             self.report_progress("Extracting exercise...", StatusType::Extracting, progress);
-            task_executor::extract_project(zip_file.path(), target)?;
+            task_executor::extract_project(zip_file.path(), target, true)?;
             progress += step;
         }
         self.report_complete("Finished downloading and extracting exercises.");
@@ -698,7 +698,7 @@ impl TmcCore {
     pub fn download_model_solution(&self, solution_download_url: Url, target: &Path) -> Result<()> {
         let zip_file = NamedTempFile::new().map_err(CoreError::TempFile)?;
         self.download_from(solution_download_url, zip_file.path())?;
-        task_executor::extract_project(zip_file.path(), target)?;
+        task_executor::extract_project(zip_file.path(), target, false)?;
         Ok(())
     }
 

tmc-langs-framework/src/plugin.rs

@@ -158,22 +158,30 @@ pub trait LanguagePlugin {
     ///
     /// This will overwrite any existing files as long as they are not specified as student files
     /// by the language dependent student file policy.
-    fn extract_project(&self, compressed_project: &Path, target_location: &Path) -> Result<()> {
+    fn extract_project(
+        &self,
+        compressed_project: &Path,
+        target_location: &Path,
+        clean: bool,
+    ) -> Result<()> {
         let policy = Self::get_student_file_policy(target_location);
-        let zip = compressed_project;
-        let target = target_location;
 
-        log::debug!("Unzipping {} to {}", zip.display(), target.display());
+        log::debug!(
+            "Unzipping {} to {}",
+            compressed_project.display(),
+            target_location.display()
+        );
 
-        let file = File::open(zip).map_err(|e| TmcError::OpenFile(zip.to_path_buf(), e))?;
+        let file = File::open(compressed_project)
+            .map_err(|e| TmcError::OpenFile(compressed_project.to_path_buf(), e))?;
         let mut zip_archive = ZipArchive::new(file)?;
 
+        // find the exercise root directory inside the archive
         let project_dir = Self::find_project_dir_in_zip(&mut zip_archive)?;
         log::debug!("Project dir in zip: {}", project_dir.display());
 
         let tmc_project_yml = policy.get_tmc_project_yml()?;
 
-        // for each file in the zip, contains its path if unzipped
         // used to clean non-student files not in the zip later
         let mut unzip_paths = HashSet::new();
 
@@ -187,18 +195,14 @@ pub trait LanguagePlugin {
                     continue;
                 }
             };
-            let path_in_target = target.join(&relative);
+            let path_in_target = target_location.join(&relative);
             log::trace!("processing {:?} -> {:?}", file_path, path_in_target);
+            unzip_paths.insert(path_in_target.clone());
 
             if file.is_dir() {
                 log::trace!("creating {:?}", path_in_target);
                 fs::create_dir_all(&path_in_target)
                     .map_err(|e| TmcError::CreateDir(path_in_target.clone(), e))?;
-                unzip_paths.insert(
-                    path_in_target
-                        .canonicalize()
-                        .map_err(|e| TmcError::Canonicalize(path_in_target.clone(), e))?,
-                );
             } else {
                 let mut write = true;
                 let mut file_contents = vec![];
@@ -218,8 +222,11 @@ pub trait LanguagePlugin {
                         .read_to_end(&mut target_file_contents)
                         .map_err(|e| TmcError::FileRead(path_in_target.clone(), e))?;
                     if file_contents == target_file_contents
-                        || (policy.is_student_file(&path_in_target, &target, &tmc_project_yml)?
-                            && !policy.is_updating_forced(&relative, &tmc_project_yml)?)
+                        || (policy.is_student_file(
+                            &path_in_target,
+                            &target_location,
+                            &tmc_project_yml,
+                        )? && !policy.is_updating_forced(&relative, &tmc_project_yml)?)
                     {
                         write = false;
                     }
@@ -237,37 +244,41 @@ pub trait LanguagePlugin {
                         .map_err(|e| TmcError::Write(path_in_target.clone(), e))?;
                 }
             }
-            unzip_paths.insert(
-                path_in_target
-                    .canonicalize()
-                    .map_err(|e| TmcError::Canonicalize(path_in_target.clone(), e))?,
-            );
         }
 
-        // delete non-student files that were not in zip
-        log::debug!("deleting non-student files not in zip");
-        log::debug!("{:?}", unzip_paths);
-        for entry in WalkDir::new(target).into_iter().filter_map(|e| e.ok()) {
-            if !unzip_paths.contains(
-                &entry
-                    .path()
-                    .canonicalize()
-                    .map_err(|e| TmcError::Canonicalize(entry.path().to_path_buf(), e))?,
-            ) && (policy.is_updating_forced(entry.path(), &tmc_project_yml)?
-                || !policy.is_student_file(entry.path(), &target, &tmc_project_yml)?)
+        if clean {
+            // delete non-student files that were not in zip
+            log::debug!("deleting non-student files not in zip");
+            log::debug!("{:?}", unzip_paths);
+            for entry in WalkDir::new(target_location)
+                .into_iter()
+                .filter_map(|e| e.ok())
             {
-                log::debug!("rm {} {}", entry.path().display(), target.display());
-                if entry.path().is_dir() {
-                    // delete if empty
-                    if WalkDir::new(entry.path()).max_depth(1).into_iter().count() == 1 {
-                        log::debug!("deleting empty directory {}", entry.path().display());
-                        fs::remove_dir(entry.path())
-                            .map_err(|e| TmcError::RemoveDir(entry.path().to_path_buf(), e))?;
+                if !unzip_paths.contains(entry.path())
+                    && (policy.is_updating_forced(entry.path(), &tmc_project_yml)?
+                        || !policy.is_student_file(
+                            entry.path(),
+                            &target_location,
+                            &tmc_project_yml,
+                        )?)
+                {
+                    log::debug!(
+                        "rm {} {}",
+                        entry.path().display(),
+                        target_location.display()
+                    );
+                    if entry.path().is_dir() {
+                        // delete if empty
+                        if WalkDir::new(entry.path()).max_depth(1).into_iter().count() == 1 {
+                            log::debug!("deleting empty directory {}", entry.path().display());
+                            fs::remove_dir(entry.path())
+                                .map_err(|e| TmcError::RemoveDir(entry.path().to_path_buf(), e))?;
+                        }
+                    } else {
+                        log::debug!("removing file {}", entry.path().display());
+                        fs::remove_file(entry.path())
+                            .map_err(|e| TmcError::RemoveFile(entry.path().to_path_buf(), e))?;
                     }
-                } else {
-                    log::debug!("removing file {}", entry.path().display());
-                    fs::remove_file(entry.path())
-                        .map_err(|e| TmcError::RemoveFile(entry.path().to_path_buf(), e))?;
                 }
             }
         }

tmc-langs-util/src/task_executor.rs

@@ -91,9 +91,13 @@ pub fn is_exercise_root_directory(path: &Path) -> bool {
 
 /// Finds the correct language plug-in for the given exercise path and calls `LanguagePlugin::extract_project`,
 /// If no language plugin matches, see `extract_project_overwrite`.
-pub fn extract_project(compressed_project: &Path, target_location: &Path) -> Result<(), TmcError> {
+pub fn extract_project(
+    compressed_project: &Path,
+    target_location: &Path,
+    clean: bool,
+) -> Result<(), TmcError> {
     if let Ok(plugin) = get_language_plugin(target_location) {
-        plugin.extract_project(compressed_project, target_location)?;
+        plugin.extract_project(compressed_project, target_location, clean)?;
     } else {
         log::debug!(
             "no matching language plugin found for {}, overwriting",
@@ -203,15 +207,24 @@ impl Plugin {
         &self,
         cmpressed_project: &Path,
         target_location: &Path,
+        clean: bool,
     ) -> Result<(), TmcError> {
         match self {
-            Self::CSharp(plugin) => plugin.extract_project(cmpressed_project, target_location),
-            Self::Make(plugin) => plugin.extract_project(cmpressed_project, target_location),
-            Self::Maven(plugin) => plugin.extract_project(cmpressed_project, target_location),
-            Self::NoTests(plugin) => plugin.extract_project(cmpressed_project, target_location),
-            Self::Python3(plugin) => plugin.extract_project(cmpressed_project, target_location),
-            Self::R(plugin) => plugin.extract_project(cmpressed_project, target_location),
-            Self::Ant(plugin) => plugin.extract_project(cmpressed_project, target_location),
+            Self::CSharp(plugin) => {
+                plugin.extract_project(cmpressed_project, target_location, clean)
+            }
+            Self::Make(plugin) => plugin.extract_project(cmpressed_project, target_location, clean),
+            Self::Maven(plugin) => {
+                plugin.extract_project(cmpressed_project, target_location, clean)
+            }
+            Self::NoTests(plugin) => {
+                plugin.extract_project(cmpressed_project, target_location, clean)
+            }
+            Self::Python3(plugin) => {
+                plugin.extract_project(cmpressed_project, target_location, clean)
+            }
+            Self::R(plugin) => plugin.extract_project(cmpressed_project, target_location, clean),
+            Self::Ant(plugin) => plugin.extract_project(cmpressed_project, target_location, clean),
         }
     }