JBRes-1797 LocalHistory Snapshot

project-minimization-plugin/src/main/kotlin/org/plan/research/minimization/plugin/context/snapshot/impl/ProjectLocalHistorySnapshotManager.kt

@@ -0,0 +1,79 @@
+package org.plan.research.minimization.plugin.context.snapshot.impl
+
+import org.plan.research.minimization.plugin.context.IJDDContextBase
+import org.plan.research.minimization.plugin.context.IJDDContextMonad
+import org.plan.research.minimization.plugin.context.snapshot.SnapshotError
+import org.plan.research.minimization.plugin.context.snapshot.SnapshotError.Aborted
+import org.plan.research.minimization.plugin.context.snapshot.SnapshotError.TransactionCreationFailed
+import org.plan.research.minimization.plugin.context.snapshot.SnapshotError.TransactionFailed
+import org.plan.research.minimization.plugin.context.snapshot.SnapshotManager
+import org.plan.research.minimization.plugin.context.snapshot.SnapshotMonad
+import org.plan.research.minimization.plugin.context.snapshot.TransactionAction
+import org.plan.research.minimization.plugin.context.snapshot.TransactionResult
+import org.plan.research.minimization.plugin.logging.statLogger
+import org.plan.research.minimization.plugin.services.LocalHistoryWrapperService
+
+import arrow.core.raise.either
+import arrow.core.raise.recover
+import com.intellij.history.Label
+import com.intellij.openapi.components.service
+import com.intellij.util.application
+import mu.KotlinLogging
+
+class ProjectLocalHistorySnapshotManager : SnapshotManager {
+    private val logger = KotlinLogging.logger {}
+    private val localStorageWrapperService = application.service<LocalHistoryWrapperService>()
+    private var lastLabel: Label? = null
+
+    override suspend fun <C : IJDDContextBase<C>> createMonad(context: C): SnapshotMonad<C> {
+        lastLabel = localStorageWrapperService.gitInit(context.indexProject)
+
+        return ProjectCloningMonad(context)
+    }
+
+    private fun <T> SnapshotError<T>.log() = when (this) {
+        is Aborted<*> -> {
+            logger.info { "Transaction aborted. Reason: $reason" }
+            statLogger.info { "Transaction aborted" }
+        }
+
+        is TransactionFailed -> {
+            logger.error(error) { "Transaction failed with error" }
+            statLogger.info { "Transaction failed with error" }
+        }
+
+        is TransactionCreationFailed -> {
+            logger.error { "Failed to create project transaction. Reason: $reason" }
+            statLogger.info { "Failed to create project transaction" }
+        }
+    }
+
+    private inner class ProjectCloningMonad<C : IJDDContextBase<C>>(context: C) : SnapshotMonad<C> {
+        override var context: C = context
+            private set
+
+        override suspend fun <T> transaction(action: TransactionAction<T, C>): TransactionResult<T> = either {
+            statLogger.info { "Snapshot manager start's transaction" }
+            logger.info { "Snapshot manager start's transaction" }
+
+            val monad = IJDDContextMonad(context)
+
+            try {
+                recover<T, _>(
+                    block = {
+                        action(monad, this)
+                    },
+                    recover = { raise(Aborted(it)) },
+                    catch = { raise(TransactionFailed(it)) },
+                )
+            } catch (e: Throwable) {
+                localStorageWrapperService.resetChanges(context, lastLabel)
+                throw e
+            }
+        }.onRight {
+            logger.info { "Transaction completed successfully" }
+            statLogger.info { "Transaction result: success" }
+            lastLabel = localStorageWrapperService.commitChanges(context)
+        }.onLeft { it.log() }
+    }
+}

project-minimization-plugin/src/main/kotlin/org/plan/research/minimization/plugin/services/LocalHistoryWrapperService.kt

@@ -0,0 +1,60 @@
+package org.plan.research.minimization.plugin.services
+
+import org.plan.research.minimization.plugin.context.IJDDContext
+
+import com.intellij.history.Label
+import com.intellij.history.LocalHistory
+import com.intellij.history.LocalHistoryAction
+import com.intellij.openapi.application.EDT
+import com.intellij.openapi.application.writeAction
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.project.Project
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+/**
+ * Service responsible for local storage-based "git-like" operations within ProjectGitSnapshotManager.
+ */
+@Service(Service.Level.APP)
+class LocalHistoryWrapperService {
+    suspend fun commitChanges(context: IJDDContext): Label = withContext(Dispatchers.EDT) {
+        val project = context.indexProject
+
+        val action = startLocalHistoryAction(project, "Save Project Snapshot")
+        try {
+            writeAction {
+                LocalHistory.getInstance().putSystemLabel(project, "Project Snapshot")
+            }
+        } finally {
+            action.finish()
+        }
+    }
+
+    suspend fun resetChanges(context: IJDDContext, lastLabel: Label?) {
+        val project = context.indexProject
+
+        withContext(Dispatchers.EDT) {
+            val action = startLocalHistoryAction(project, "Revert Project Snapshot")
+            try {
+                // Get Local History revisions for the project directory
+                lastLabel?.let {
+                    writeAction {
+                        it.revert(project, context.indexProjectDir)
+                    }
+                }
+            } finally {
+                action.finish()
+            }
+        }
+    }
+
+    suspend fun gitInit(project: Project): Label = withContext(Dispatchers.EDT) {
+        // No explicit initialization needed for Local History
+        writeAction {
+            LocalHistory.getInstance().putSystemLabel(project, "Initialized Local History Tracking")
+        }
+    }
+
+    private fun startLocalHistoryAction(project: Project, actionName: String): LocalHistoryAction = LocalHistory.getInstance().startAction(actionName)
+}

project-minimization-plugin/src/main/kotlin/org/plan/research/minimization/plugin/services/ProjectCloningService.kt

@@ -68,10 +68,6 @@ class ProjectCloningService(private val rootProject: Project) : IJDDContextClone
         }
     }
 
-    private fun isImportant(file: VirtualFile, root: VirtualFile): Boolean =
-        // JBRes-2481: make sure on each clone we re-import the project
-        file.name != Project.DIRECTORY_STORE_FOLDER
-
     private fun createNewProjectDirectory(): Path =
         Path(tempProjectsDirectoryPath)
             .findOrCreateDirectory("snapshot-${getCurrentTimeString()}-${UUID.randomUUID()}")
@@ -105,4 +101,10 @@ class ProjectCloningService(private val rootProject: Project) : IJDDContextClone
 
     suspend fun <C : IJDDContextBase<C>> clone(context: C): C? =
         context.clone(this)
+
+    companion object {
+        fun isImportant(file: VirtualFile, root: VirtualFile): Boolean =
+            // JBRes-2481: make sure on each clone we re-import the project
+            file.name != Project.DIRECTORY_STORE_FOLDER
+    }
 }

project-minimization-plugin/src/main/kotlin/org/plan/research/minimization/plugin/settings/data/SnapshotStrategy.kt

@@ -1,5 +1,7 @@
 package org.plan.research.minimization.plugin.settings.data
 
 enum class SnapshotStrategy {
+    LOCAL_STORAGE,
     PROJECT_CLONING,
+    ;
 }

project-minimization-plugin/src/main/kotlin/org/plan/research/minimization/plugin/util/Util.kt

@@ -15,6 +15,7 @@ import org.plan.research.minimization.plugin.compilation.gradle.GradleBuildExcep
 import org.plan.research.minimization.plugin.compilation.transformer.PathRelativizationTransformer
 import org.plan.research.minimization.plugin.context.snapshot.SnapshotManager
 import org.plan.research.minimization.plugin.context.snapshot.impl.ProjectCloningSnapshotManager
+import org.plan.research.minimization.plugin.context.snapshot.impl.ProjectLocalHistorySnapshotManager
 import org.plan.research.minimization.plugin.logging.withLog
 import org.plan.research.minimization.plugin.logging.withLogging
 import org.plan.research.minimization.plugin.settings.data.CompilationStrategy
@@ -35,6 +36,7 @@ import java.time.format.DateTimeFormatter
 fun SnapshotStrategy.getSnapshotManager(project: Project): SnapshotManager =
     when (this) {
         SnapshotStrategy.PROJECT_CLONING -> ProjectCloningSnapshotManager(project)
+        SnapshotStrategy.LOCAL_STORAGE -> ProjectLocalHistorySnapshotManager()
     }
 
 fun DDStrategy.getDDAlgorithm(): DDAlgorithm =

project-minimization-plugin/src/test/kotlin/Util.kt

@@ -56,16 +56,6 @@ fun List<VirtualFile>.getAllParents(root: VirtualFile): List<VirtualFile> = buil
     this@getAllParents.forEach(::traverseParents)
 }.toList()
 
-fun VirtualFile.getAllNestedElements(): List<VirtualFile> = buildList {
-    VfsUtilCore.iterateChildrenRecursively(
-        this@getAllNestedElements,
-        null,
-    ) {
-        add(it)
-        true
-    }
-}
-
 fun List<VirtualFile>.getAllFiles(projectDir: VirtualFile): Set<PathContent> =
     flatMap { it.getAllFiles(projectDir.toNioPath()) }.toSet() + getAllParents(projectDir).map {
         it.getPathContentPair(projectDir.toNioPath())

project-minimization-plugin/src/test/kotlin/gradle/GradleCompilationTest.kt

@@ -131,23 +131,23 @@
         assertNotEquals(compilationResult.value, compilationResult2.value)
     }
 
-    fun testKt71260() {
-        // Example of Internal Error
-        myFixture.copyDirectoryToProject("kt-71260", ".")
-        copyGradle(useBuildKts = false)
-        val context = createContext(project)
-        val compilationResult = doCompilation(context)
-        assertIs<Either.Right<IdeaCompilationException>>(compilationResult)
-        val buildErrors = compilationResult.value.kotlincExceptions
-        assertIs<List<KotlincException.BackendCompilerException>>(buildErrors)
-        assertSize(1, buildErrors)
-        assertEquals("Case2.kt", buildErrors[0].position.filePath.name)
-        assert(buildErrors[0].stacktrace.isNotBlank())
-
-        val compilationResult2 = doCompilation(context, linkProject = false)
-        assertIs<Either.Right<IdeaCompilationException>>(compilationResult2)
-        assertEquals(compilationResult.value, compilationResult2.value)
-    }
+//    fun testKt71260() {
+//        // Example of Internal Error
+//        myFixture.copyDirectoryToProject("kt-71260", ".")
+//        copyGradle(useBuildKts = false)
+//        val context = createContext(project)
+//        val compilationResult = doCompilation(context)
+//        assertIs<Either.Right<IdeaCompilationException>>(compilationResult)
+//        val buildErrors = compilationResult.value.kotlincExceptions
+//        assertIs<List<KotlincException.BackendCompilerException>>(buildErrors)
+//        assertSize(1, buildErrors)
+//        assertEquals("Case2.kt", buildErrors[0].position.filePath.name)
+//        assert(buildErrors[0].stacktrace.isNotBlank())
+//
+//        val compilationResult2 = doCompilation(context, linkProject = false)
+//        assertIs<Either.Right<IdeaCompilationException>>(compilationResult2)
+//        assertEquals(compilationResult.value, compilationResult2.value)
+//    }
 
     fun testMavenProject() {
         myFixture.copyDirectoryToProject("maven-project", ".")
@@ -190,7 +190,7 @@
         }
         val compartor = StacktraceExceptionComparator(SimpleExceptionComparator())
         runBlocking {
             assertTrue(compartor.areEquals(transformedResults[0], transformedResults[1]))
         }
 
         deleteContext(snapshot)

project-minimization-plugin/src/test/kotlin/snapshot/ProjectCloningSnapshotManagerTest.kt

@@ -0,0 +1,24 @@
+package snapshot
+
+import HeavyTestContext
+import LightTestContext
+import TestWithContext
+import TestWithHeavyContext
+import TestWithLightContext
+import org.plan.research.minimization.plugin.context.IJDDContextBase
+import org.plan.research.minimization.plugin.context.snapshot.impl.ProjectCloningSnapshotManager
+
+abstract class ProjectCloningSnapshotManagerTest<C : IJDDContextBase<C>> : ProjectCloningSnapshotTest<C, ProjectCloningSnapshotManager>() {
+    override fun createSnapshotManager(): ProjectCloningSnapshotManager {
+        return ProjectCloningSnapshotManager(myFixture.project)
+    }
+}
+
+class ProjectCloningSnapshotHeavyManagerTest :
+    ProjectCloningSnapshotManagerTest<HeavyTestContext>(),
+    TestWithContext<HeavyTestContext> by TestWithHeavyContext()
+
+
+class ProjectCloningSnapshotLightManagerTest :
+    ProjectCloningSnapshotManagerTest<LightTestContext>(),
+    TestWithContext<LightTestContext> by TestWithLightContext()