Multi-IDE Support and more Run-Configurations

build.gradle.kts

@@ -2,8 +2,8 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     id("java")
-    kotlin("jvm") version "1.8.10"
-    id("org.jetbrains.intellij") version "1.13.3"
+    kotlin("jvm") version "1.9.0"
+    id("org.jetbrains.intellij") version "1.15.0"
 }
 
 java {
@@ -30,17 +30,17 @@ dependencies {
 // See /~https://github.com/JetBrains/gradle-intellij-plugin/
 intellij {
     pluginName.set("orion")
-    version.set("2023.1")
-    plugins.set(listOf("Git4Idea", "maven", "PythonCore:231.8109.144"))
+    version.set("2023.2.1")
+    plugins.set(listOf("Git4Idea", "PythonCore:232.9559.62", "maven", "gradle"))
 }
 
 tasks {
     patchPluginXml {
         // Last 2 digits of the year and the major version digit, 211-211.* equals (20)21.1.*
         // See https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
-        sinceBuild.set("231")
+        sinceBuild.set("232")
         // Orion Plugin version. Needs to be incremented for every new release!
-        version.set("1.2.3")
+        version.set("1.2.4")
         changeNotes.set(
             """<p>
             <h1>Removed Deprecation</h1>

src/main/java/de/tum/www1/orion/OrionStartupProjectRefreshActivity.kt

@@ -4,7 +4,7 @@ import com.intellij.openapi.application.invokeAndWaitIfNeeded
 import com.intellij.openapi.components.service
 import com.intellij.openapi.project.DumbAware
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.startup.StartupActivity
+import com.intellij.openapi.startup.ProjectActivity
 import de.tum.www1.orion.connector.client.JavaScriptConnector
 import de.tum.www1.orion.connector.ide.vcs.submit.ChangeSubmissionContext
 import de.tum.www1.orion.enumeration.ExerciseView
@@ -19,15 +19,15 @@ import de.tum.www1.orion.util.OrionAssessmentUtils
 import de.tum.www1.orion.util.appService
 import de.tum.www1.orion.util.translate
 
-class OrionStartupProjectRefreshActivity : StartupActivity, DumbAware {
+class OrionStartupProjectRefreshActivity : ProjectActivity, DumbAware {
 
     /**
      * Runs all pending jobs on opening a programming exercise project. For now, this includes:
      * - Registering the opened exercise in the registry
      * - Pull all changes from the remote
      * - Tell the Artemis webapp that a new exercise was opened
      */
-    override fun runActivity(project: Project) {
+    override suspend fun execute(project: Project) {
         // We need to subscribe to all internal state listeners before any message could potentially be sent
         project.service<JavaScriptConnector>().initIDEStateListeners()
         // If the exercise was opened for the first time
@@ -64,4 +64,6 @@ class OrionStartupProjectRefreshActivity : StartupActivity, DumbAware {
             project.service<OrionExerciseService>().updateExercise()
         }
     }
+
+
 }

src/main/java/de/tum/www1/orion/build/instructor/OrionLocalRunConfigurationSettingsFactory.kt → src/main/java/de/tum/www1/orion/build/OrionLocalRunConfigurationSettingsFactory.kt

@@ -1,7 +1,10 @@
-package de.tum.www1.orion.build.instructor
+package de.tum.www1.orion.build
 
 import com.intellij.execution.RunnerAndConfigurationSettings
+import com.intellij.openapi.application.ApplicationInfo
 import com.intellij.openapi.project.Project
+import de.tum.www1.orion.build.instructor.JavaRunConfigurationProvider
+import de.tum.www1.orion.build.instructor.OrionInstructorBuildUtil
 import de.tum.www1.orion.enumeration.ProgrammingLanguage
 import de.tum.www1.orion.util.selectedProgrammingLanguage
 import java.io.File.separatorChar
@@ -11,30 +14,39 @@ import java.io.File.separatorChar
  */
 object OrionLocalRunConfigurationSettingsFactory {
     /**
-     * Creates a run configuration for maven clean test working in the merged_test directory
+     * Creates a run configuration working in the merged_test directory
      *
      * @param project project to generate the configuration for
      * @return the configuration
      */
-    fun runConfigurationForInstructor(project: Project): RunnerAndConfigurationSettings {
+    fun runConfigurationForInstructor(project: Project): RunnerAndConfigurationSettings? {
+
         return when (project.selectedProgrammingLanguage()) {
-            ProgrammingLanguage.JAVA -> JavaRunConfigurationProvider(project).provideBuildAndTestRunConfiguration("${project.basePath!!}$separatorChar${OrionInstructorBuildUtil.LOCAL_TEST_DIRECTORY}")
-            else -> throw IllegalArgumentException("Unsupported programming language for run configuration " + project.selectedProgrammingLanguage())
+            ProgrammingLanguage.JAVA -> {
+                //check if its Intellij
+                val applicationInfo = ApplicationInfo.getInstance().fullApplicationName
+                if (!applicationInfo.contains("IntelliJ")) {
+                    return null
+                }
+
+                JavaRunConfigurationProvider(project).provideBuildAndTestRunConfiguration("${project.basePath!!}$separatorChar${OrionInstructorBuildUtil.LOCAL_TEST_DIRECTORY}")
+            }
+
+            else -> return null
         }
     }
 
     /**
-     * Creates a run configuration for maven clean test working in the base directory
+     * Creates a run configuration working in the base directory
      *
      * @param project project to generate the configuration for
      * @return the configuration
      */
-    fun runConfigurationForTutor(project: Project): RunnerAndConfigurationSettings {
+    fun runConfigurationForTutor(project: Project): RunnerAndConfigurationSettings? {
         return when (project.selectedProgrammingLanguage()) {
-            // maven clean test should work for any language
             else -> JavaRunConfigurationProvider(project).provideBuildAndTestRunConfiguration(
                 project.basePath!!
             )
         }
     }
-}
+}

src/main/java/de/tum/www1/orion/build/OrionTestInterceptor.kt

@@ -126,9 +126,9 @@ class OrionTestInterceptor(private val project: Project) : OrionTestParser {
             .split(",")
         val parent = when {
             // child of previous node
-            previousNode?.level ?: Int.MAX_VALUE < level -> previousNode
+            (previousNode?.level ?: Int.MAX_VALUE) < level -> previousNode
             // same level as parent of previous node
-            previousNode?.level ?: Int.MIN_VALUE > level -> parentNode!!.parent
+            (previousNode?.level ?: Int.MIN_VALUE) > level -> parentNode!!.parent
             // same level as previous node
             else -> parentNode
         }

src/main/java/de/tum/www1/orion/build/instructor/JavaRunConfigurationProvider.kt

@@ -6,19 +6,48 @@ import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import org.jetbrains.idea.maven.execution.MavenRunConfiguration
 import org.jetbrains.idea.maven.execution.MavenRunConfigurationType
+import org.jetbrains.plugins.gradle.service.execution.GradleExternalTaskConfigurationType
+import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration
+import java.io.File
 
 class JavaRunConfigurationProvider(val project: Project) : OrionRunConfigurationProvider {
-    override fun provideBuildAndTestRunConfiguration(workingDir: String): RunnerAndConfigurationSettings {
+    /**
+     * Provides a java run configuration for maven/gradle projects
+     */
+    override fun provideBuildAndTestRunConfiguration(workingDir: String): RunnerAndConfigurationSettings? {
+
+
+        val gradleBuildFile = File("$workingDir/build.gradle")
+        val mavenBuildFile = File("$workingDir/pom.xml")
+
         val runManager = project.service<RunManager>()
-        val runConfigurationSettings =
-            runManager.createConfiguration("Orion Maven Build & Test Locally", MavenRunConfigurationType::class.java)
-        (runConfigurationSettings.configuration as MavenRunConfiguration).apply {
-            runnerParameters.apply {
-                goals = listOf("clean", "test")
-                workingDirPath = workingDir
+
+        // decide between maven and gradle
+        if (gradleBuildFile.exists() && !gradleBuildFile.isDirectory) {
+            val gradleRunConfigurationSettings = runManager.createConfiguration(
+                "Orion Build & Test locally",
+                GradleExternalTaskConfigurationType::class.java
+            )
+            (gradleRunConfigurationSettings.configuration as GradleRunConfiguration).apply {
+                rawCommandLine = "clean test"
+
             }
-        }
+            return gradleRunConfigurationSettings
+        } else if (mavenBuildFile.exists() && !mavenBuildFile.isDirectory) {
+            val mavenRunConfigurationSettings =
+                runManager.createConfiguration(
+                    "Orion Maven Build & Test Locally",
+                    MavenRunConfigurationType::class.java
+                )
+            (mavenRunConfigurationSettings.configuration as MavenRunConfiguration).apply {
+                runnerParameters.apply {
 
-        return runConfigurationSettings
+                    goals = listOf("clean", "test")
+                    workingDirPath = workingDir
+                }
+            }
+            return mavenRunConfigurationSettings
+        }
+        return null
     }
 }

src/main/java/de/tum/www1/orion/build/instructor/OrionInstructorBuildUtil.kt

@@ -14,6 +14,7 @@ import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.vfs.LocalFileSystem
 import com.intellij.openapi.vfs.VfsUtil
 import com.intellij.openapi.vfs.VirtualFile
+import de.tum.www1.orion.build.OrionLocalRunConfigurationSettingsFactory
 import de.tum.www1.orion.dto.RepositoryType
 import de.tum.www1.orion.enumeration.ProgrammingLanguage
 import de.tum.www1.orion.exercise.registry.OrionStudentExerciseRegistry
@@ -41,7 +42,7 @@ enum class RepositoryCheckoutPath : CustomizableCheckoutPath {
     TEST {
         override fun forProgrammingLanguage(language: ProgrammingLanguage): String {
             return when (language) {
-                ProgrammingLanguage.JAVA, ProgrammingLanguage.PYTHON -> ""
+                ProgrammingLanguage.JAVA, ProgrammingLanguage.PYTHON, ProgrammingLanguage.KOTLIN -> ""
                 ProgrammingLanguage.C -> "tests"
                 // runTestsLocally should prevent any other language from reaching this line
                 else -> throw UnsupportedOperationException(
@@ -55,6 +56,9 @@ enum class RepositoryCheckoutPath : CustomizableCheckoutPath {
 }
 
 class OrionInstructorBuildUtil(val project: Project) {
+    /**
+     * A function to run tests locally
+     */
     fun runTestsLocally() {
         val language = project.selectedProgrammingLanguage() ?: return Unit.also {
             when (val exerciseLanguage = project.service<OrionStudentExerciseRegistry>().exerciseInfo?.language) {
@@ -95,9 +99,11 @@ class OrionInstructorBuildUtil(val project: Project) {
                 )
             }
         }
-
+        // creates a run configuration
         val runConfigurationSettings = OrionLocalRunConfigurationSettingsFactory.runConfigurationForInstructor(project)
-        ExecutionUtil.runConfiguration(runConfigurationSettings, DefaultRunExecutor.getRunExecutorInstance())
+        if (runConfigurationSettings != null) {
+            ExecutionUtil.runConfiguration(runConfigurationSettings, DefaultRunExecutor.getRunExecutorInstance())
+        }
         project.messageBus.connect().subscribe(ExecutionManager.EXECUTION_TOPIC, object : ExecutionListener {
             override fun processTerminated(
                 executorId: String,

src/main/java/de/tum/www1/orion/build/instructor/OrionRunConfigurationProvider.kt

@@ -3,5 +3,5 @@ package de.tum.www1.orion.build.instructor
 import com.intellij.execution.RunnerAndConfigurationSettings
 
 interface OrionRunConfigurationProvider {
-    fun provideBuildAndTestRunConfiguration(workingDir: String): RunnerAndConfigurationSettings
+    fun provideBuildAndTestRunConfiguration(workingDir: String): RunnerAndConfigurationSettings?
 }

src/main/java/de/tum/www1/orion/connector/ide/OrionConnector.kt

@@ -12,12 +12,12 @@ import java.util.*
 /**
  * Represent a class which is responsible for initializing JS to Java communication
  *
- * When a Java handler is added to a CefBrowser instance (via JBCEFJSQuery wrapper in this case, JCEF will inject into
+ * When a Java handler is added to a CefBrowser instance (via JBCEFJSQuery wrapper in this case), JCEF will inject into
  * the window object of the loaded page's Javascript a cefQuery function. Message to Java can be conducted by invoking
  * in JS this function and passing the message. If there are multiple handlers attached, a random handler will receive
  * the message. Propagation of message to other handlers is done by setting the return value of onQuery to false. To
  * make sure that the message is dispatched to the right handler, we use message of the form:
-"handlerName \n param1 \n param2 \n param3 \n ...
+ * "handlerName \n param1 \n param2 \n param3 \n ..."
  * See https://appdoc.app/artifact/org.bitbucket.johness/java-cef/49.87.win32.2/index.html?org/cef/handler/CefRequestHandler.html
  * for more information.
  *

src/main/java/de/tum/www1/orion/connector/ide/exercise/IOrionExerciseConnector.kt

@@ -21,7 +21,6 @@ interface IOrionExerciseConnector {
      *
      * @param submissionId id of the submission, used to navigate to the corresponding URL
      * @param correctionRound correction round, also needed to navigate to the correct URL
-     * @param testRun true if in a test run, also needed for navigation
      * @param base64data data of the zip file containing the student's repository
      */
     // Uncomment this to activate transfer of the testRun flag

src/main/java/de/tum/www1/orion/connector/ide/vcs/submit/ChangeSubmissionContext.java

@@ -21,16 +21,11 @@ public void determineSubmissionStrategy() {
         final var currentView = project.getService(OrionStudentExerciseRegistry.class).getCurrentView();
         if (currentView != null) {
             switch (currentView) {
-                case STUDENT:
-                    this.submissionStrategy = new StudentChangeSubmissionStrategy(project);
-                    break;
-                case INSTRUCTOR:
-                    this.submissionStrategy = new InstructorChangeSubmissionStrategy(project);
-                    break;
-                default:
+                case STUDENT -> this.submissionStrategy = new StudentChangeSubmissionStrategy(project);
+                case INSTRUCTOR -> this.submissionStrategy = new InstructorChangeSubmissionStrategy(project);
+                default ->
                     // Tutors may never submit
-                    this.submissionStrategy = null;
-                    break;
+                        this.submissionStrategy = null;
             }
         }
     }

src/main/java/de/tum/www1/orion/dto/BuildLogErrors.kt

@@ -12,9 +12,7 @@ data class BuildLogFileErrorsDTO(val fileName: String, val errors: List<BuildErr
         other as BuildLogFileErrorsDTO
 
         if (fileName != other.fileName) return false
-        if (errors != other.errors) return false
-
-        return true
+        return errors == other.errors
     }
 
     override fun hashCode(): Int {

src/main/java/de/tum/www1/orion/exercise/OrionExerciseService.kt

@@ -46,6 +46,7 @@ class OrionExerciseService(private val project: Project) {
         cloneFunction: (chosenPath: String, globalRegistry: OrionGlobalExerciseRegistryService) -> Unit
     ) {
         val registry = service<OrionGlobalExerciseRegistryService>()
+
         if (!registry.isImported(exercise.id, exerciseView)) {
             runInEdt(ModalityState.NON_MODAL) {
                 val chooser = ImportPathChooser(project, exercise, exerciseView)

src/main/java/de/tum/www1/orion/exercise/OrionJavaTutorProjectCreator.kt

@@ -7,7 +7,7 @@ import com.intellij.openapi.module.ModuleManager
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.vfs.VirtualFileManager
-import de.tum.www1.orion.build.instructor.OrionLocalRunConfigurationSettingsFactory
+import de.tum.www1.orion.build.OrionLocalRunConfigurationSettingsFactory
 import de.tum.www1.orion.ui.util.notify
 import de.tum.www1.orion.util.OrionAssessmentUtils.getAssignmentOf
 import de.tum.www1.orion.util.translate
@@ -34,8 +34,10 @@ object OrionJavaTutorProjectCreator {
 
     private fun configureRunConfiguration(project: Project) {
         val runConfiguration = OrionLocalRunConfigurationSettingsFactory.runConfigurationForTutor(project)
-        runConfiguration.storeInDotIdeaFolder()
-        RunManager.getInstance(project).addConfiguration(runConfiguration)
+        if (runConfiguration != null) {
+            runConfiguration.storeInDotIdeaFolder()
+            RunManager.getInstance(project).addConfiguration(runConfiguration)
+        }
     }
 
     /**

src/main/java/de/tum/www1/orion/exercise/registry/OrionGlobalExerciseRegistryService.java

@@ -65,16 +65,11 @@ private void initState() {
     }
 
     private Map<Long, String> selectMap(ExerciseView view) {
-        switch (view) {
-            case STUDENT:
-                return myState.studentImports;
-            case TUTOR:
-                return myState.tutorImports;
-            case INSTRUCTOR:
-                return myState.instructorImports;
-            default:
-                throw new IllegalStateException("Data requested for non-existing exercise view " + view);
-        }
+        return switch (view) {
+            case STUDENT -> myState.studentImports;
+            case TUTOR -> myState.tutorImports;
+            case INSTRUCTOR -> myState.instructorImports;
+        };
     }
 
     public void relinkExercise(long id, ExerciseView view, @SystemIndependent String path) {

src/main/java/de/tum/www1/orion/exercise/registry/OrionProjectRegistryStateService.kt

@@ -120,9 +120,13 @@ class OrionProjectRegistryStateService(private val myProject: Project) :
         }
     }
 
+    /**
+     * Suggests SDK to use for the freshly opened project.
+     */
     private fun State.guessProjectSdk() {
         val availableSdks: List<Sdk> = when (this.language) {
             ProgrammingLanguage.JAVA -> ProjectJdkTable.getInstance().allJdks.toList()
+            ProgrammingLanguage.KOTLIN -> ProjectJdkTable.getInstance().allJdks.toList()
             ProgrammingLanguage.PYTHON -> PythonSdkUtil.getAllSdks()
             else -> return
         }

src/main/java/de/tum/www1/orion/ui/OrionRouterService.kt

@@ -48,7 +48,7 @@ class OrionRouterService(private val project: Project) : OrionRouter {
     }
 
     override fun routeForDocumentation(): String {
-        return "https://artemis-platform.readthedocs.io/en/latest/user/orion"
+        return "https://docs.artemis.cit.tum.de/user/orion"
     }
 
     companion object {

src/main/java/de/tum/www1/orion/ui/assessment/OrionAssessmentEditor.kt

@@ -25,10 +25,9 @@ class OrionAssessmentEditor(
     private val relativePath: String,
     private val file: VirtualFile
 ) : FileEditorBase() {
-    private val headerLabel: JLabel
+    private val headerLabel: JLabel = createHeader(translate("orion.exercise.assessmentModeLoading").uppercase())
 
     init {
-        headerLabel = createHeader(translate("orion.exercise.assessmentModeLoading").uppercase())
         myEditor.headerComponent = headerLabel
 
         initializeFeedback()