Improve work with course config

Author: meanmail

intellij-plugin/hs-core/src/org/hyperskill/academy/learning/InitializationListener.kt

@@ -16,6 +16,7 @@ import com.intellij.openapi.vfs.VfsUtil
 import com.intellij.util.PathUtil
 import org.hyperskill.academy.learning.authUtils.OAuthUtils.isBuiltinPortValid
 import org.hyperskill.academy.learning.courseFormat.Course
+import org.hyperskill.academy.learning.courseFormat.hyperskill.HyperskillCourse
 import org.hyperskill.academy.learning.messages.EduCoreBundle
 import org.hyperskill.academy.learning.newproject.coursesStorage.CoursesStorage
 import org.hyperskill.academy.learning.notification.EduNotificationManager
@@ -103,21 +104,33 @@ class InitializationListener : AppLifecycleListener, DynamicPluginListener {
     val recentPathsInfo = state.additionalInfo
     recentPathsInfo.forEach {
       val projectPath = it.key
-      val course = deserializeCourse(projectPath)
+      val course = deserializeHyperskillCourse(projectPath)
       if (course != null) {
         // Note: we don't set course progress here, because we didn't load course items here
         CoursesStorage.getInstance().addCourse(course, projectPath)
       }
     }
   }
 
-  private fun deserializeCourse(projectPath: String): Course? {
+  /**
+   * Deserializes course from the given project path, returning only Hyperskill courses.
+   * Non-Hyperskill courses are handled by other plugins (e.g., JetBrains Academy).
+   */
+  private fun deserializeHyperskillCourse(projectPath: String): Course? {
     val projectFile = File(PathUtil.toSystemDependentName(projectPath))
     val projectDir = VfsUtil.findFile(projectFile.toPath(), true) ?: return null
     val courseConfig = projectDir.findChild(YamlConfigSettings.COURSE_CONFIG) ?: return null
     return runReadAction {
-      ProgressManager.getInstance().computeInNonCancelableSection<Course, Exception> {
-        YamlMapper.basicMapper().deserializeCourse(VfsUtil.loadText(courseConfig))
+      ProgressManager.getInstance().computeInNonCancelableSection<Course?, Exception> {
+        try {
+          val course = YamlMapper.basicMapper().deserializeCourse(VfsUtil.loadText(courseConfig))
+          // Only return Hyperskill courses, ignore other course types
+          if (course is HyperskillCourse) course else null
+        }
+        catch (e: Exception) {
+          // Ignore deserialization errors for non-Hyperskill courses
+          null
+        }
       }
     }
   }

intellij-plugin/hs-core/src/org/hyperskill/academy/learning/yaml/YamlFormatSettings.kt

@@ -3,6 +3,8 @@ package org.hyperskill.academy.learning.yaml
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Key
+import com.intellij.openapi.vfs.VfsUtil
+import com.intellij.openapi.vfs.VirtualFile
 import org.hyperskill.academy.learning.StudyTaskManager
 import org.hyperskill.academy.learning.guessCourseDir
 import org.hyperskill.academy.learning.isUnitTestMode
@@ -12,8 +14,11 @@ object YamlFormatSettings {
   private val YAML_IS_EDU_PROJECT: Key<Boolean> = Key.create("EDU.yaml_is_edu_project")
 
   /**
-   * Determines whether current project looks like an Edu YAML project by checking
-   * if course config file exists in the project (course) root.
+   * Determines whether current project is a Hyperskill course project by checking
+   * if course config file exists and has type "hyperskill".
+   *
+   * Non-Hyperskill course types (like "coursera", "pycharm", etc.) are handled by
+   * other plugins (e.g., JetBrains Academy plugin) and should be ignored here.
    *
    * IMPORTANT: Avoids VFS access on EDT. On UI thread, returns cached value if present
    * or schedules background computation and returns false as a conservative default.
@@ -26,7 +31,7 @@ object YamlFormatSettings {
     return if (app.isDispatchThread) {
       // Don't touch VFS on EDT. Compute in background and cache for subsequent calls.
       app.executeOnPooledThread {
-        val result = guessCourseDir()?.findChild(COURSE_CONFIG) != null
+        val result = isHyperskillCourseProject()
         putUserData(YAML_IS_EDU_PROJECT, result)
         if (result) {
           // Trigger StudyTaskManager initialization to load course once detection is ready
@@ -37,12 +42,37 @@ object YamlFormatSettings {
       false
     }
     else {
-      val result = guessCourseDir()?.findChild(COURSE_CONFIG) != null
+      val result = isHyperskillCourseProject()
       putUserData(YAML_IS_EDU_PROJECT, result)
       result
     }
   }
 
+  /**
+   * Checks if the project contains a Hyperskill course by examining the course config file.
+   * Returns true only for courses with type "hyperskill".
+   */
+  private fun Project.isHyperskillCourseProject(): Boolean {
+    val courseConfig = guessCourseDir()?.findChild(COURSE_CONFIG) ?: return false
+    return isHyperskillCourseConfig(courseConfig)
+  }
+
+  /**
+   * Parses the course config file to check if it's a Hyperskill course (type: hyperskill).
+   * Uses simple text parsing to avoid full YAML deserialization overhead.
+   */
+  private fun isHyperskillCourseConfig(configFile: VirtualFile): Boolean {
+    return try {
+      val content = VfsUtil.loadText(configFile)
+      // Look for "type: hyperskill" or "type:hyperskill" at the beginning of a line
+      val typeRegex = """(?m)^type:\s*hyperskill\s*$""".toRegex()
+      typeRegex.containsMatchIn(content)
+    }
+    catch (e: Exception) {
+      false
+    }
+  }
+
   // it is here because it's used in test and main code
   val YAML_TEST_PROJECT_READY = Key<Boolean>("EDU.yaml_test_project_ready")
   val YAML_TEST_THROW_EXCEPTION = Key<Boolean>("EDU.yaml_test_throw_exception")