Added automatic snapshot of uncommited changes before merge

Fixes #214

Author: JetpackDuba

src/main/composeResources/values/strings.xml

@@ -77,4 +77,8 @@
     <string name="uncommited_changes_primary_button_skip">Skip</string>
     <string name="uncommited_changes_secondary_button_abort">Abort</string>
     <string name="uncommited_changes_amend_check">Amend previous commit</string>
+
+    <!-- Merge automatic stash -->
+    <string name="merge_automatic_stash_description">Automatic stash before merge of "%1$s" to "%2$s"</string>
+    <string name="pull_with_merge_automatic_stash_description">Automatic stash before pull of "%1$s"</string>
 </resources>

src/main/kotlin/com/jetpackduba/gitnuro/git/branches/MergeBranchUseCase.kt

@@ -1,19 +1,51 @@
 package com.jetpackduba.gitnuro.git.branches
 
 import com.jetpackduba.gitnuro.exceptions.UncommittedChangesDetectedException
+import com.jetpackduba.gitnuro.extensions.simpleName
+import com.jetpackduba.gitnuro.generated.resources.Res
+import com.jetpackduba.gitnuro.generated.resources.merge_automatic_stash_description
+import com.jetpackduba.gitnuro.git.stash.DeleteStashUseCase
+import com.jetpackduba.gitnuro.git.stash.SnapshotStashCreateCommand
+import com.jetpackduba.gitnuro.git.workspace.CheckHasUncommittedChangesUseCase
+import com.jetpackduba.gitnuro.repositories.AppSettingsRepository
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.api.MergeCommand
 import org.eclipse.jgit.api.MergeResult
 import org.eclipse.jgit.lib.Ref
+import org.eclipse.jgit.revwalk.RevCommit
+import org.jetbrains.compose.resources.getString
 import javax.inject.Inject
 
-class MergeBranchUseCase @Inject constructor() {
+class MergeBranchUseCase @Inject constructor(
+    private val checkHasUncommittedChangesUseCase: CheckHasUncommittedChangesUseCase,
+    private val deleteStashUseCase: DeleteStashUseCase,
+    private val appSettingsRepository: AppSettingsRepository,
+) {
     /**
      * @return true if success has conflicts, false if success without conflicts
      */
     suspend operator fun invoke(git: Git, branch: Ref, fastForward: Boolean) = withContext(Dispatchers.IO) {
+        var backupStash: RevCommit? = null
+
+        if (appSettingsRepository.mergeAutoStash) {
+            val hasUncommitedChanges = checkHasUncommittedChangesUseCase(git)
+            if (hasUncommitedChanges) {
+                val snapshotStashCreateCommand = SnapshotStashCreateCommand(
+                    repository = git.repository,
+                    workingDirectoryMessage = getString(
+                        Res.string.merge_automatic_stash_description,
+                        branch.simpleName,
+                        git.repository.branch
+                    ),
+                    includeUntracked = true
+                )
+
+                backupStash = snapshotStashCreateCommand.call()
+            }
+        }
+
         val fastForwardMode = if (fastForward)
             MergeCommand.FastForwardMode.FF
         else
@@ -29,6 +61,12 @@ class MergeBranchUseCase @Inject constructor() {
             throw UncommittedChangesDetectedException("Merge failed, makes sure you repository doesn't contain uncommitted changes.")
         }
 
-        mergeResult.mergeStatus == MergeResult.MergeStatus.CONFLICTING
+        val hasConflicts = mergeResult.mergeStatus == MergeResult.MergeStatus.CONFLICTING
+
+        if (!hasConflicts && backupStash != null) {
+            deleteStashUseCase(git, backupStash)
+        }
+
+        return@withContext hasConflicts
     }
 }

src/main/kotlin/com/jetpackduba/gitnuro/git/remote_operations/PullBranchUseCase.kt

@@ -1,18 +1,27 @@
 package com.jetpackduba.gitnuro.git.remote_operations
 
+import com.jetpackduba.gitnuro.generated.resources.Res
+import com.jetpackduba.gitnuro.generated.resources.pull_with_merge_automatic_stash_description
+import com.jetpackduba.gitnuro.git.stash.DeleteStashUseCase
+import com.jetpackduba.gitnuro.git.stash.SnapshotStashCreateCommand
+import com.jetpackduba.gitnuro.git.workspace.CheckHasUncommittedChangesUseCase
 import com.jetpackduba.gitnuro.repositories.AppSettingsRepository
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.lib.ConfigConstants
 import org.eclipse.jgit.lib.Repository
+import org.eclipse.jgit.revwalk.RevCommit
 import org.eclipse.jgit.transport.CredentialsProvider
+import org.jetbrains.compose.resources.getString
 import javax.inject.Inject
 
 class PullBranchUseCase @Inject constructor(
+    private val checkHasUncommittedChangesUseCase: CheckHasUncommittedChangesUseCase,
     private val handleTransportUseCase: HandleTransportUseCase,
     private val appSettingsRepository: AppSettingsRepository,
     private val hasPullResultConflictsUseCase: HasPullResultConflictsUseCase,
+    private val deleteStashUseCase: DeleteStashUseCase,
 ) {
     suspend operator fun invoke(git: Git, pullType: PullType): PullHasConflicts = withContext(Dispatchers.IO) {
         useBuiltinLfs(git.repository) {
@@ -22,7 +31,26 @@ class PullBranchUseCase @Inject constructor(
                 PullType.DEFAULT -> appSettingsRepository.pullRebase
             }
 
-            handleTransportUseCase(git) {
+            val pullWithMerge = !pullWithRebase
+            var backupStash: RevCommit? = null
+
+            if (appSettingsRepository.mergeAutoStash && pullWithMerge) {
+                val hasUncommitedChanges = checkHasUncommittedChangesUseCase(git)
+                if (hasUncommitedChanges) {
+                    val snapshotStashCreateCommand = SnapshotStashCreateCommand(
+                        repository = git.repository,
+                        workingDirectoryMessage = getString(
+                            Res.string.pull_with_merge_automatic_stash_description,
+                            git.repository.branch
+                        ),
+                        includeUntracked = true
+                    )
+
+                    backupStash = snapshotStashCreateCommand.call()
+                }
+            }
+
+            val pullHasConflicts = handleTransportUseCase(git) {
                 val pullResult = git
                     .pull()
                     .setTransportConfigCallback { this.handleTransport(it) }
@@ -32,6 +60,13 @@ class PullBranchUseCase @Inject constructor(
 
                 return@handleTransportUseCase hasPullResultConflictsUseCase(pullWithRebase, pullResult)
             }
+
+            if (!pullHasConflicts && backupStash != null) {
+                deleteStashUseCase(git, backupStash)
+            }
+
+            pullHasConflicts
+
         }
     }
 }