Add Adam's modified plugin and study question files for pilot study

Author: AdamKolodziejczak

Dockerfile

@@ -1,14 +1,14 @@
 # Stage 1: Cache Gradle dependencies
-FROM gradle:8.5-jdk17 AS cache
+FROM gradle:latest AS cache
 RUN mkdir -p /home/gradle/cache_home
-ENV GRADLE_USER_HOME=/home/gradle/cache_home
+ENV GRADLE_USER_HOME /home/gradle/cache_home
 COPY build.gradle.* gradle.properties /home/gradle/app/
 COPY gradle /home/gradle/app/gradle
 WORKDIR /home/gradle/app
 RUN gradle clean build -i --stacktrace
 
 # Stage 2: Build Application
-FROM gradle:8.5-jdk17 AS build
+FROM gradle:latest AS build
 COPY --from=cache /home/gradle/cache_home /home/gradle/.gradle
 COPY . /usr/src/app/
 WORKDIR /usr/src/app
@@ -17,9 +17,10 @@ WORKDIR /home/gradle/src
 RUN gradle ij-server:buildFatJar --no-daemon
 
 # Stage 3: Create the Runtime Image
-FROM amazoncorretto:17 AS runtime
+FROM amazoncorretto:11 AS runtime
 EXPOSE 8080
-RUN mkdir /app
+RUN mkdir /app \
+# Make sure /data/tt-files directory exists in the runtime image
 RUN mkdir -p /data/tt-files && chmod -R 777 /data/tt-files
 COPY --from=build /home/gradle/src/ij-server/build/libs/ij-server-all.jar /app/ktor-docker-sample.jar
-ENTRYPOINT ["java","-jar","/app/ktor-docker-sample.jar"]
+ENTRYPOINT ["java","-jar","/app/ktor-docker-sample.jar"]

docker-compose.yml

@@ -1,10 +1,9 @@
 services:
   server:
-    image: koala-server:latest  # Create the local image: docker build --platform linux/amd64 -t koala-server .
-    platform: linux/amd64
+    image: registry.jetbrains.team/p/tasktracker-3/sharable/tasktracker-server:latest
     ports:
       - "8080:8080"
     environment:
-      - DB_URL=jdbc:postgresql://host.docker.internal:5432/koala
-      - DB_USERNAME=
-      - DB_PASSWORD=
+      - DB_URL=jdbc:postgresql://host.docker.internal:5432/tasktracker
+      - DB_USERNAME=adamk4
+      - DB_PASSWORD=Dzieciaki2

gradle.properties

@@ -1,8 +1,8 @@
 # IntelliJ Platform Artifacts Repositories -> https://plugins.jetbrains.com/docs/intellij/intellij-artifacts.html
 
 pluginGroup = org.jetBrains.research.tasktracker
-pluginName = KOALA
-pluginRepositoryUrl = https://github.com/JetBrains-Research/KOALA
+pluginName = TaskTracker-3
+pluginRepositoryUrl = https://github.com/JetBrains-Research/tasktracker-3
 # SemVer format -> https://semver.org
 pluginVersion = 0.1.0
 

ij-plugin/build.gradle.kts

@@ -101,8 +101,8 @@ tasks {
     }
 
     withType<JavaCompile> {
-        sourceCompatibility = jdkVersion
-        targetCompatibility = JavaVersion.VERSION_21.toString()
+        sourceCompatibility = "21"
+        targetCompatibility = "21"
     }
     withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
         compilerOptions.jvmTarget.set(JvmTarget.JVM_21)
@@ -113,3 +113,14 @@ tasks {
     }
 
 }
+
+kotlin {
+    jvmToolchain(21)
+}
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(21))
+    }
+}
+

ij-plugin/src/main/kotlin/org/jetbrains/research/tasktracker/tracking/logger/BaseLogger.kt

@@ -1,5 +1,7 @@
 package org.jetbrains.research.tasktracker.tracking.logger
 
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.application.runWriteAction
 import com.intellij.openapi.util.io.FileUtil
 import com.jetbrains.rd.util.AtomicInteger
 import org.apache.commons.csv.CSVFormat
@@ -19,56 +21,48 @@ abstract class BaseLogger {
 
     private val logPrinters = mutableListOf<LogPrinter>()
     private val atomicInteger = AtomicInteger(0)
-    private val lock = Any()
 
     protected fun log(dataToPrint: Iterable<*>) {
         val logPrinter = getActiveLogPrinter()
-        // Writing to a plain file via CSVPrinter does not require IDE write action; just ensure thread-safety.
-        synchronized(lock) {
-            logPrinter.csvPrinter.printRecord(dataToPrint)
+        ApplicationManager.getApplication().invokeLater {
+            runWriteAction { logPrinter.csvPrinter.printRecord(dataToPrint) }
         }
     }
 
     /**
      * Gets the active logPrinter or creates a new one if there was none or the active one was full
      */
-    private fun getActiveLogPrinter(): LogPrinter = synchronized(lock) {
+    private fun getActiveLogPrinter(): LogPrinter {
         val activePrinter = getLastPrinter()
-        if (activePrinter.isFull()) {
+        return if (activePrinter.isFull()) {
             addLogPrinter()
         } else {
             activePrinter
         }
     }
 
-    private fun getLastPrinter(): LogPrinter = synchronized(lock) {
-        if (logPrinters.isEmpty()) {
-            addLogPrinter()
-        } else {
-            logPrinters.last()
-        }
+    private fun getLastPrinter() = if (logPrinters.isEmpty()) {
+        addLogPrinter()
+    } else {
+        logPrinters.last()
     }
 
-    private fun addLogPrinter(): LogPrinter = synchronized(lock) {
-        val logFile = createLogFile("${logPrinterFilename}${atomicInteger.getAndIncrement()}.csv")
+    private fun addLogPrinter(): LogPrinter {
+        val logFile = createLogFile("$logPrinterFilename${atomicInteger.getAndIncrement()}.csv")
         val fileWriter = OutputStreamWriter(FileOutputStream(logFile), StandardCharsets.UTF_8)
         val csvPrinter = CSVPrinter(fileWriter, CSVFormat.DEFAULT)
-        csvPrinter.printRecord(loggedData.headers)
+        runWriteAction { csvPrinter.printRecord(loggedData.headers) }
         logPrinters.add(LogPrinter(csvPrinter, fileWriter, logFile))
-        logPrinters.last()
+        return logPrinters.last()
     }
 
-    private fun createLogFile(fileName: String): File {
-        val logDir = File(MainTaskTrackerConfig.logFilesFolder)
-        if (!logDir.exists()) {
-            logDir.mkdirs()
-        }
+    private fun createLogFile(fileName: String): File = runWriteAction {
         val logFile = File("${MainTaskTrackerConfig.logFilesFolder}/$fileName")
         FileUtil.createIfDoesntExist(logFile)
-        return logFile
+        logFile
     }
 
-    fun getLogFiles(): List<File> = synchronized(lock) {
+    fun getLogFiles(): List<File> = runWriteAction {
         logPrinters.map {
             it.csvPrinter.flush()
             it.logFile

ij-plugin/src/main/resources/org/jetbrains/research/tasktracker/config/content/task/question_five.py

@@ -0,0 +1,43 @@
+# Test 1: Basic mixed word
+#   Input:  tour
+#   Output: .t.r
+
+# Test 2: Mixed case word
+#   Input:  CodeForces
+#   Output: .c.d.f.r.c.s
+
+# Test 3: All uppercase vowels - empty output
+#   Input:  AEIOU
+#   Output: (empty)
+
+# Test 4: All lowercase vowels - empty output
+#   Input:  aeiou
+#   Output: (empty)
+
+# Test 5: All uppercase consonants - lowercased with dots
+#   Input:  BCDFG
+#   Output: .b.c.d.f.g
+
+# Test 6: All lowercase consonants
+#   Input:  bcdfg
+#   Output: .b.c.d.f.g
+
+# Test 7: Lowercase y is a vowel - empty output
+#   Input:  y
+#   Output: (empty)
+
+# Test 8: Both y and Y are vowels - empty output
+#   Input:  yY
+#   Output: (empty)
+
+# Test 9: Y at start of word is removed as vowel (common mistake)
+#   Input:  Yes
+#   Output: .s
+
+# Test 10: Y between consonants - Y removed
+#   Input:  zYz
+#   Output: .z.z
+
+# Test 11: Single consonant
+#   Input:  b
+#   Output: .b

ij-plugin/src/main/resources/org/jetbrains/research/tasktracker/config/content/task/question_four.py

@@ -0,0 +1,36 @@
+# Test 1: Two words not separated by WUB - they become one word
+#   Input:  WUBWUBHELLOWORLDWUB
+#   Output: HELLOWORLD
+
+
+# Test 1: Example from problem
+#   Input:  WUBWUBIWUBAMWUBWUBX
+#   Output: I AM X
+
+# Test 2: Leading and trailing WUBs
+#   Input:  WUBHELLOWUBWORLDWUB
+#   Output: HELLO WORLD
+
+# Test 3: Multiple WUBs only - empty output
+#   Input:  WUBWUBWUB
+#   Output: (empty)
+
+# Test 4: No WUBs at all - word printed as-is
+#   Input:  HELLO
+#   Output: HELLO
+
+# Test 5: Two words not separated by WUB - become one word (common mistake)
+#   Input:  WUBWUBHELLOWORLDWUB
+#   Output: HELLOWORLD
+
+# Test 6: Single word wrapped in WUBs
+#   Input:  WUBHELLOWUB
+#   Output: HELLO
+
+# Test 7: WUB splits two single letters
+#   Input:  AWUBB
+#   Output: A B
+
+# Test 8: Multiple single letter words
+#   Input:  WUBAWUBBWUBCWUB
+#   Output: A B C

ij-plugin/src/main/resources/org/jetbrains/research/tasktracker/config/content/task/question_one.py

@@ -0,0 +1,27 @@
+# Test 1: Normal short word - no change
+#   Input:  word
+#   Output: word
+
+# Test 2: Normal long word - abbreviate
+#   Input:  localization
+#   Output: l10n
+
+# Test 3: Exactly 10 characters - should NOT abbreviate (common off-by-one mistake)
+#   Input:  abcdefghij
+#   Output: abcdefghij
+
+# Test 4: Exactly 11 characters - should abbreviate (boundary)
+#   Input:  abcdefghijk
+#   Output: a9k
+
+# Test 5: First and last letter are the same
+#   Input:  abcdefghija
+#   Output: a9a
+
+# Test 6: All same letter (11 chars)
+#   Input:  aaaaaaaaaaa
+#   Output: a9a
+
+# Test 7: Very long word
+#   Input:  internationalization
+#   Output: i18n

ij-plugin/src/main/resources/org/jetbrains/research/tasktracker/config/content/task/question_six.py

@@ -0,0 +1,47 @@
+# Test 1: Basic - 1 digit divisible by 2
+#   Input:  1 2
+#   Output: 2
+
+# Test 2: Basic - 3 digits divisible by 4
+#   Input:  3 4
+#   Output: 100
+
+# Test 3: t=1, every number works - smallest n-digit number
+#   Input:  1 1
+#   Output: 1
+
+# Test 4: t=1 with 2 digits
+#   Input:  2 1
+#   Output: 10
+
+# Test 5: t=1 with 3 digits
+#   Input:  3 1
+#   Output: 100
+
+# Test 6: Last single digit (9)
+#   Input:  1 9
+#   Output: 9
+
+# Test 7: No single digit divisible by 10 - must print -1 (common mistake to skip -1 case)
+#   Input:  1 10
+#   Output: -1
+
+# Test 8: No single digit divisible by 11
+#   Input:  1 11
+#   Output: -1
+
+# Test 9: 2-digit number divisible by 10
+#   Input:  2 10
+#   Output: 10
+
+# Test 10: 2-digit number, t equals the number itself
+#   Input:  2 99
+#   Output: 99
+
+# Test 11: 2-digit prime as t
+#   Input:  2 97
+#   Output: 97
+
+# Test 12: t larger than any n-digit number
+#   Input:  1 97
+#   Output: -1

ij-plugin/src/main/resources/org/jetbrains/research/tasktracker/config/content/task/question_three.py

@@ -0,0 +1,47 @@
+# Test 1: Basic safe - alternating
+#   Input:  010101
+#   Output: YES
+
+# Test 2: Exactly 7 zeros - dangerous
+#   Input:  0000000
+#   Output: NO
+
+# Test 3: Exactly 7 ones - dangerous
+#   Input:  1111111
+#   Output: NO
+
+# Test 4: Exactly 6 zeros - safe (off-by-one mistake)
+#   Input:  000000
+#   Output: YES
+
+# Test 5: Exactly 6 ones - safe
+#   Input:  111111
+#   Output: YES
+
+# Test 6: 8 zeros - dangerous
+#   Input:  00000000
+#   Output: NO
+
+# Test 7: Run of 7 at the start
+#   Input:  11111110
+#   Output: NO
+
+# Test 8: Run of 7 in the middle
+#   Input:  011111110
+#   Output: NO
+
+# Test 9: Run of 7 at the end
+#   Input:  01111111
+#   Output: NO
+
+# Test 10: 7 ones present but only 6 zeros - still dangerous
+#   Input:  00000011111110
+#   Output: NO
+
+# Test 11: Both 0s and 1s hit 7 in a row
+#   Input:  000000011111110
+#   Output: NO
+
+# Test 12: Long alternating string (100 chars) - safe
+#   Input:  0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101
+#   Output: YES