Merge pull request #1195 from Aalto-LeTech/misc-fixes

jaakkonakaza · web-flow · commit 4ba2c7a22b44 · 2025-02-05T10:13:53.000+02:00
Misc fixes
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,6 +8,10 @@
 
 - Support for the Programming 2 course and SBT modules
 
+### Fixed
+
+- Do not submit backups of updated modules
+
 ## [4.2.0] - 2025-01-08
 
 ### Fixed
diff --git a/src/main/kotlin/fi/aalto/cs/apluscourses/generator/APlusModuleBuilder.kt b/src/main/kotlin/fi/aalto/cs/apluscourses/generator/APlusModuleBuilder.kt
@@ -49,19 +49,21 @@ internal class APlusModuleBuilder : ModuleBuilder() {
             super.createAndCommitIfNeeded(project, model, true)
         }
 
-        project.service<ProjectInitializationTracker>()
-            .addInitializationTask {
-                val startTime = System.currentTimeMillis()
+        if (config.programmingLanguage == "scala") {
 
-                // The version string only starts with "java version" when the JDK is not downloaded completely
-                while ((ProjectRootManager.getInstance(
-                        project
-                    ).projectSdk?.versionString?.startsWith("java version") != false) && System.currentTimeMillis() - startTime < 300 * 1000
-                ) {
-                    Thread.sleep(1000)
-                }
-            }
+            project.service<ProjectInitializationTracker>()
+                .addInitializationTask {
+                    val startTime = System.currentTimeMillis()
 
+                    // The version string only starts with "java version" when the JDK is not downloaded completely
+                    while ((ProjectRootManager.getInstance(
+                            project
+                        ).projectSdk?.versionString?.startsWith("java version") != false) && System.currentTimeMillis() - startTime < 300 * 1000
+                    ) {
+                        Thread.sleep(1000)
+                    }
+                }
+        }
 
         return listOf(module)
     }
diff --git a/src/main/kotlin/fi/aalto/cs/apluscourses/generator/CourseSelectStep.kt b/src/main/kotlin/fi/aalto/cs/apluscourses/generator/CourseSelectStep.kt
@@ -27,10 +27,10 @@ import javax.swing.JComponent
 import javax.swing.JList
 
 class CourseSelectStep(private val config: APlusModuleConfig) : ModuleWizardStep() {
-    private val courses = AtomicProperty<List<CoursesFetcher.CourseConfig>>(emptyList())
+    private val courses = AtomicProperty<List<CoursesFetcher.CourseInfo>>(emptyList())
 
     private val courseConfigUrl = AtomicProperty("")
-    private val course = AtomicProperty<CoursesFetcher.CourseConfig?>(null)
+    private val course = AtomicProperty<CoursesFetcher.CourseInfo?>(null)
     private val language = AtomicProperty(PluginSettings.SUPPORTED_LANGUAGES.first())
 
     init {
@@ -62,10 +62,10 @@ class CourseSelectStep(private val config: APlusModuleConfig) : ModuleWizardStep
                     text(message("generator.APlusModuleBuilder.selectCourse"))
                 }
                 row {
-                    list(courses, object : ColoredListCellRenderer<CoursesFetcher.CourseConfig>() {
+                    list(courses, object : ColoredListCellRenderer<CoursesFetcher.CourseInfo>() {
                         override fun customizeCellRenderer(
-                            list: JList<out CoursesFetcher.CourseConfig>,
-                            item: CoursesFetcher.CourseConfig?,
+                            list: JList<out CoursesFetcher.CourseInfo>,
+                            item: CoursesFetcher.CourseInfo?,
                             index: Int,
                             selected: Boolean,
                             hasFocus: Boolean
diff --git a/src/main/kotlin/fi/aalto/cs/apluscourses/model/component/Module.kt b/src/main/kotlin/fi/aalto/cs/apluscourses/model/component/Module.kt
@@ -24,6 +24,7 @@ import fi.aalto.cs.apluscourses.utils.FileUtil
 import fi.aalto.cs.apluscourses.utils.Version
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import org.jetbrains.annotations.NonNls
 import java.nio.file.Path
 import java.nio.file.StandardCopyOption
 import kotlin.io.path.exists
@@ -51,8 +52,7 @@ open class Module(
         get() = CourseFileManager.getInstance(project).getMetadata(name)
 
     override fun findDependencies(): Set<String> {
-        val module = platformObject
-        if (module == null) return emptySet()
+        val module = platformObject ?: return emptySet()
         return module
             .rootManager
             .orderEntries()
@@ -130,7 +130,7 @@ open class Module(
                 !UpdateModuleDialog(project, this@Module, filesWithChanges).showAndGet()
             }
             if (canceled) return
-            val backupDir = fullPath.resolve("backup")
+            val backupDir = fullPath.resolve(backupDir)
 
             for (file in filesWithChanges) {
                 val relativePath = fullPath.relativize(file)
@@ -143,12 +143,12 @@ open class Module(
             }
         }
 
-        FileUtil.deleteFilesInDirectory(fullPath.toFile(), fullPath.resolve("backup"))
+        FileUtil.deleteFilesInDirectory(fullPath.toFile(), fullPath.resolve(backupDir))
         downloadAndInstall(updating = true)
 
         val newFiles = FileUtil.getAllFilesInDirectory(fullPath.toFile())
-        val deletedFiles = allFiles - newFiles
-        val addedFiles = newFiles - allFiles
+        val deletedFiles = allFiles - newFiles.toSet()
+        val addedFiles = newFiles - allFiles.toSet()
         Notifier.notifyAndHide(
             ModuleUpdatedNotification(this, addedFiles, deletedFiles),
             project
@@ -199,6 +199,9 @@ open class Module(
         }
 
     companion object {
+        @NonNls
+        val backupDir: String = "backup"
+
 
         /**
          * This class is a [RootPolicy] that builds a set of the names of those
diff --git a/src/main/kotlin/fi/aalto/cs/apluscourses/services/ModuleImportExport.kt b/src/main/kotlin/fi/aalto/cs/apluscourses/services/ModuleImportExport.kt
@@ -61,12 +61,10 @@ class ModuleImportExport(
 
                             val zipFile = FileUtil.createTempDirectory("apluscourses", "modules")
                             zip.entries().asSequence().forEach { entry ->
-                                // Fix: Replace backslashes with slashes in entry names
-                                val fixedEntryName = entry.name.replace('\\', '/')
-                                val entryName = if (fixedEntryName.endsWith(".iml")) {
+                                val entryName = if (entry.name.endsWith(".iml")) {
                                     "$desiredModuleName.iml"
                                 } else {
-                                    fixedEntryName
+                                    entry.name
                                 }
                                 val entryFile = File(zipFile, entryName)
 
@@ -193,7 +191,9 @@ class ModuleImportExport(
 
                     moduleDir.walkTopDown()
                         .forEach { file ->
-                            // Fix: Use forward slashes in zip entry names
+                            // File names in ZIP should always use forward slashes.
+                            // See section 4.4.17 of the ".ZIP File Format Specification" v6.3.6 FINAL.
+                            // Available online: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
                             val relativePath = file.relativeTo(moduleDir).invariantSeparatorsPath
                             val entryName = if (file.isDirectory) {
                                 "$relativePath/"
diff --git a/src/main/kotlin/fi/aalto/cs/apluscourses/services/course/CoursesFetcher.kt b/src/main/kotlin/fi/aalto/cs/apluscourses/services/course/CoursesFetcher.kt
@@ -3,10 +3,10 @@ package fi.aalto.cs.apluscourses.services.course
 import com.intellij.openapi.components.Service
 import fi.aalto.cs.apluscourses.api.CourseConfig
 import fi.aalto.cs.apluscourses.utils.CoursesLogger
-import io.ktor.client.HttpClient
-import io.ktor.client.engine.cio.CIO
-import io.ktor.client.request.get
-import io.ktor.client.statement.bodyAsText
+import io.ktor.client.*
+import io.ktor.client.engine.cio.*
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
@@ -16,16 +16,16 @@ import org.yaml.snakeyaml.Yaml
 
 @Service(Service.Level.APP)
 class CoursesFetcher(private val cs: CoroutineScope) {
-    data class CourseConfig(
+    data class CourseInfo(
         val name: String,
         val semester: String,
         val url: String,
         val language: String?
     ) {
         companion object {
             @NonNls
-            fun fromYaml(map: Map<String, String>): CourseConfig {
-                return CourseConfig(map["name"]!!, map["semester"]!!, map["url"]!!, map["language"])
+            fun fromYaml(map: Map<String, String>): CourseInfo {
+                return CourseInfo(map["name"]!!, map["semester"]!!, map["url"]!!, map["language"])
             }
         }
     }
@@ -35,7 +35,7 @@ class CoursesFetcher(private val cs: CoroutineScope) {
         isLenient = true
     }
 
-    fun fetchCourses(setCourses: (List<CoursesFetcher.CourseConfig>) -> Unit) {
+    fun fetchCourses(setCourses: (List<CourseInfo>) -> Unit) {
         cs.launch {
             val client = HttpClient(CIO) {
                 engine {
@@ -48,7 +48,7 @@ class CoursesFetcher(private val cs: CoroutineScope) {
             val courses = Yaml()
                 .load<List<Map<String, String>>>(res.bodyAsText())
                 .map { course: Map<String, String> ->
-                    CourseConfig.fromYaml(course)
+                    CourseInfo.fromYaml(course)
                 }
 
             setCourses(courses)
diff --git a/src/main/kotlin/fi/aalto/cs/apluscourses/services/exercise/ExercisesTreeFilter.kt b/src/main/kotlin/fi/aalto/cs/apluscourses/services/exercise/ExercisesTreeFilter.kt
@@ -8,11 +8,9 @@ import com.intellij.util.messages.Topic
 import com.intellij.util.messages.Topic.ProjectLevel
 import com.intellij.util.xmlb.annotations.XCollection
 import fi.aalto.cs.apluscourses.BUNDLE
-import fi.aalto.cs.apluscourses.ui.exercise.ExercisesView.ExerciseGroupItem
-import fi.aalto.cs.apluscourses.ui.exercise.ExercisesView.ExerciseItem
-import fi.aalto.cs.apluscourses.ui.exercise.ExercisesView.ExercisesTreeItem
+import fi.aalto.cs.apluscourses.ui.exercise.ExercisesView.*
 import org.jetbrains.annotations.PropertyKey
-import java.util.Collections
+import java.util.*
 import kotlin.reflect.KClass
 
 @Service(Service.Level.PROJECT)
@@ -28,7 +26,7 @@ class ExercisesTreeFilter(private val project: Project) :
             valueAttributeName = "",
             style = XCollection.Style.v2
         )
-        var enabledFilters by list<String>()
+        var enabledFilters: MutableList<String> by list()
     }
 
     private val filters: MutableMap<Filter<out ExercisesTreeItem>, Boolean> =
@@ -54,7 +52,7 @@ class ExercisesTreeFilter(private val project: Project) :
         }
     }
 
-    fun saveState() {
+    private fun saveState() {
         state.enabledFilters = filters.entries
             .filter { it.value }
             .map { it.key.displayName }.toMutableList()
@@ -75,7 +73,10 @@ class ExercisesTreeFilter(private val project: Project) :
             // Filter out disabled filters and match the target type
             .filter { it.value && it.key.targetType == targetType }
             // Map to filter functions with correct type
-            .map { it.key.getFilterFunction() as (T) -> Boolean }
+            .map {
+                @Suppress("UNCHECKED_CAST", "HardCodedStringLiteral")
+                it.key.getFilterFunction() as (T) -> Boolean
+            }
             // Combine filters to a single lambda
             .fold({ false }) { acc, filter -> { item -> filter(item) || acc(item) } }
 
@@ -89,7 +90,7 @@ class ExercisesTreeFilter(private val project: Project) :
 
         class ExerciseItemFilter(
             displayName: String,
-            private val filter: (ExerciseItem) -> Boolean
+            val filter: (ExerciseItem) -> Boolean
         ) : Filter<ExerciseItem>(displayName, ExerciseItem::class) {
             override fun getFilterFunction(): (ExerciseItem) -> Boolean = filter
         }
@@ -102,23 +103,24 @@ class ExercisesTreeFilter(private val project: Project) :
         }
 
         companion object {
-            val NON_SUBMITTABLE = ExerciseItemFilter(
+            private val NON_SUBMITTABLE: ExerciseItemFilter = ExerciseItemFilter(
                 "services.ExercisesTreeFilter.nonSubmittable"
-            ) { item -> !item.exercise.isSubmittable }
+            ) { !it.exercise.isSubmittable }
 
-            val COMPLETED = ExerciseItemFilter(
+            private val COMPLETED: ExerciseItemFilter = ExerciseItemFilter(
                 "services.ExercisesTreeFilter.Completed"
-            ) { item -> item.exercise.isCompleted() }
+            ) { it.exercise.isCompleted() }
 
-            val OPTIONAL = ExerciseItemFilter(
+            private val OPTIONAL: ExerciseItemFilter = ExerciseItemFilter(
                 "services.ExercisesTreeFilter.Optional"
-            ) { item -> item.exercise.isOptional }
+            ) { it.exercise.isOptional }
 
-            val CLOSED = ExerciseGroupFilter(
+            private val CLOSED: ExerciseGroupFilter = ExerciseGroupFilter(
                 "services.ExercisesTreeFilter.Closed"
-            ) { item -> !item.group.isOpen }
+            ) { !it.group.isOpen }
 
-            val allFilters = listOf(NON_SUBMITTABLE, COMPLETED, OPTIONAL, CLOSED)
+            val allFilters: List<Filter<out ExercisesTreeItem>> =
+                listOf(NON_SUBMITTABLE, COMPLETED, OPTIONAL, CLOSED)
         }
     }
 
diff --git a/src/main/kotlin/fi/aalto/cs/apluscourses/services/exercise/SubmitExercise.kt b/src/main/kotlin/fi/aalto/cs/apluscourses/services/exercise/SubmitExercise.kt
@@ -1,12 +1,14 @@
 package fi.aalto.cs.apluscourses.services.exercise
 
 import com.intellij.openapi.application.EDT
+import com.intellij.openapi.application.writeAction
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.openapi.module.ModuleUtilCore
 import com.intellij.openapi.project.Project
 import com.intellij.serialization.PropertyMapping
 import fi.aalto.cs.apluscourses.api.APlusApi
+import fi.aalto.cs.apluscourses.model.component.Module
 import fi.aalto.cs.apluscourses.model.exercise.Exercise
 import fi.aalto.cs.apluscourses.model.exercise.Submission
 import fi.aalto.cs.apluscourses.model.exercise.SubmissionInfo
@@ -85,7 +87,9 @@ class SubmitExercise(
                 }
 
                 withContext(Dispatchers.EDT) {
-                    FileDocumentManager.getInstance().saveAllDocuments()
+                    writeAction {
+                        FileDocumentManager.getInstance().saveAllDocuments()
+                    }
                 }
 
                 var modulePath = Path(ModuleUtilCore.getModuleDirPath(platformModule))
@@ -99,10 +103,12 @@ class SubmitExercise(
                 val files: MutableMap<String, Path> = HashMap()
                 for ((key, name) in submissionInfo.getFiles(language)) {
                     files[key] = FileUtil.findFileInDirectory(modulePath.invariantSeparatorsPathString, name)
-                        ?: throw FileDoesNotExistException(
-                            modulePath.invariantSeparatorsPathString,
-                            name
-                        )
+                    { file ->
+                        !file.invariantSeparatorsPath.startsWith("${module.fullPath.resolve(Module.backupDir).invariantSeparatorsPathString}/")
+                    } ?: throw FileDoesNotExistException(
+                        modulePath.invariantSeparatorsPathString,
+                        name
+                    )
                 }
                 CoursesLogger.info("Submission files: $files")
 
diff --git a/src/main/kotlin/fi/aalto/cs/apluscourses/utils/FileUtil.kt b/src/main/kotlin/fi/aalto/cs/apluscourses/utils/FileUtil.kt
@@ -41,9 +41,13 @@ object FileUtil {
      * @param directory The directory to search for the file.
      * @param fileName The name of the file to find.
      */
-    fun findFileInDirectory(directory: String, fileName: String): Path? {
+    fun findFileInDirectory(
+        directory: String,
+        fileName: String,
+        filter: (File) -> Boolean = { _: File -> true }
+    ): Path? {
         return File(directory).walk().find {
-            it.name == fileName
+            it.name == fileName && filter(it)
         }?.toPath()
     }
 
diff --git a/src/main/kotlin/fi/aalto/cs/apluscourses/utils/parser/O1NewsParser.kt b/src/main/kotlin/fi/aalto/cs/apluscourses/utils/parser/O1NewsParser.kt
