Updated JGit to 7.0.0

build.gradle.kts

@@ -47,7 +47,7 @@ repositories {
 }
 
 dependencies {
-    val jgit = "6.9.0.202403050737-r"
+    val jgit = "7.0.0.202409031743-r"
 
     if (currentOs() == OS.LINUX && isLinuxAarch64) {
         implementation(compose.desktop.linux_arm64)

src/main/kotlin/com/jetpackduba/gitnuro/App.kt

@@ -43,7 +43,8 @@ import com.jetpackduba.gitnuro.ui.components.TabInformation
 import com.jetpackduba.gitnuro.ui.context_menu.AppPopupMenu
 import com.jetpackduba.gitnuro.ui.dialogs.settings.ProxyType
 import kotlinx.coroutines.launch
-import org.eclipse.jgit.lib.GpgSigner
+import org.eclipse.jgit.lib.Signer
+import org.eclipse.jgit.lib.SignerFactory
 import java.io.File
 import java.io.FileOutputStream
 import java.net.Authenticator
@@ -64,9 +65,6 @@ class App {
     @Inject
     lateinit var appSettingsRepository: AppSettingsRepository
 
-    @Inject
-    lateinit var appGpgSigner: AppGpgSigner
-
     @Inject
     lateinit var appEnvInfo: AppEnvInfo
 
@@ -108,8 +106,6 @@ class App {
 
         tabsManager.loadPersistedTabs()
 
-        GpgSigner.setDefault(appGpgSigner)
-
         if (dirToOpen != null)
             addDirTab(dirToOpen)
 

src/main/kotlin/com/jetpackduba/gitnuro/git/AppGpgSigner.kt

@@ -4,10 +4,7 @@ import com.jetpackduba.gitnuro.credentials.GpgCredentialsProvider
 import org.bouncycastle.openpgp.PGPException
 import org.eclipse.jgit.api.errors.CanceledException
 import org.eclipse.jgit.gpg.bc.internal.BouncyCastleGpgSigner
-import org.eclipse.jgit.lib.CommitBuilder
-import org.eclipse.jgit.lib.GpgConfig
-import org.eclipse.jgit.lib.ObjectBuilder
-import org.eclipse.jgit.lib.PersonIdent
+import org.eclipse.jgit.lib.*
 import org.eclipse.jgit.transport.CredentialsProvider
 import javax.inject.Inject
 import javax.inject.Provider
@@ -15,47 +12,57 @@ import javax.inject.Provider
 private const val INVALID_PASSWORD_MESSAGE = "Is the entered passphrase correct?"
 
 class AppGpgSigner @Inject constructor(
-    private val gpgCredentialsProvider: Provider<GpgCredentialsProvider>,
+    private val gpgCredentials: GpgCredentialsProvider,
 ) : BouncyCastleGpgSigner() {
+
     override fun sign(
-        commit: CommitBuilder,
-        gpgSigningKey: String,
-        committer: PersonIdent,
+        repository: Repository?,
+        config: GpgConfig?,
+        data: ByteArray?,
+        committer: PersonIdent?,
+        signingKey: String?,
         credentialsProvider: CredentialsProvider?
-    ) {
-        super.sign(commit, gpgSigningKey, committer, gpgCredentialsProvider.get())
+    ): GpgSignature {
+        return try {
+            var gpgSignature: GpgSignature? = null
+            retryIfWrongPassphrase { isRetry ->
+                gpgCredentials.isRetry = isRetry
+                gpgSignature = super.sign(repository, config, data, committer, signingKey, gpgCredentials)
+                gpgCredentials.savePasswordInMemory()
+            }
+
+            gpgSignature!!
+        } catch (ex: CanceledException) {
+            println("Signing cancelled")
+            throw ex
+        }
+
     }
 
     override fun canLocateSigningKey(
-        gpgSigningKey: String,
-        committer: PersonIdent,
+        repository: Repository?,
+        config: GpgConfig?,
+        committer: PersonIdent?,
+        signingKey: String?,
         credentialsProvider: CredentialsProvider?
     ): Boolean {
-        return super.canLocateSigningKey(gpgSigningKey, committer, gpgCredentialsProvider.get())
-    }
-
-    override fun canLocateSigningKey(
-        gpgSigningKey: String,
-        committer: PersonIdent,
-        credentialsProvider: CredentialsProvider?,
-        config: GpgConfig?
-    ): Boolean {
-        return super.canLocateSigningKey(gpgSigningKey, committer, gpgCredentialsProvider.get(), config)
+        return super.canLocateSigningKey(repository, config, committer, signingKey, gpgCredentials)
     }
 
     override fun signObject(
-        `object`: ObjectBuilder,
-        gpgSigningKey: String?,
-        committer: PersonIdent,
-        credentialsProvider: CredentialsProvider?,
-        config: GpgConfig?
+        repository: Repository?,
+        config: GpgConfig?,
+        `object`: ObjectBuilder?,
+        committer: PersonIdent?,
+        signingKey: String?,
+        credentialsProvider: CredentialsProvider?
     ) {
-        val gpgCredentialsProvider = gpgCredentialsProvider.get()
+        val gpgCredentialsProvider = gpgCredentials
 
         try {
             retryIfWrongPassphrase { isRetry ->
                 gpgCredentialsProvider.isRetry = isRetry
-                super.signObject(`object`, gpgSigningKey, committer, gpgCredentialsProvider, config)
+                super.signObject(repository, config, `object`, committer, signingKey, credentialsProvider)
                 gpgCredentialsProvider.savePasswordInMemory()
             }
         } catch (ex: CanceledException) {

src/main/kotlin/com/jetpackduba/gitnuro/git/workspace/DoCommitUseCase.kt

@@ -1,6 +1,7 @@
 package com.jetpackduba.gitnuro.git.workspace
 
 import com.jetpackduba.gitnuro.extensions.isMerging
+import com.jetpackduba.gitnuro.git.AppGpgSigner
 import com.jetpackduba.gitnuro.git.author.LoadAuthorUseCase
 import com.jetpackduba.gitnuro.git.config.LoadSignOffConfigUseCase
 import com.jetpackduba.gitnuro.git.config.LocalConfigConstants
@@ -15,7 +16,8 @@ import javax.inject.Inject
 class DoCommitUseCase @Inject constructor(
     private val loadSignOffConfigUseCase: LoadSignOffConfigUseCase,
     private val loadAuthorUseCase: LoadAuthorUseCase,
-    private val getRepositoryStateUseCase: GetRepositoryStateUseCase
+    private val getRepositoryStateUseCase: GetRepositoryStateUseCase,
+    private val appGpgSigner: AppGpgSigner,
 ) {
     suspend operator fun invoke(
         git: Git,
@@ -23,6 +25,7 @@ class DoCommitUseCase @Inject constructor(
         amend: Boolean,
         author: PersonIdent?,
     ): RevCommit = withContext(Dispatchers.IO) {
+
         val signOffConfig = loadSignOffConfigUseCase(git.repository)
 
         val finalMessage = if (signOffConfig.isEnabled) {
@@ -40,6 +43,7 @@ class DoCommitUseCase @Inject constructor(
         val isMerging = state.isMerging
 
         git.commit()
+            .setSigner(appGpgSigner)
             .setMessage(finalMessage)
             .setAllowEmpty(amend || isMerging) // Only allow empty commits when amending
             .setAmend(amend)