Added submodules init option

src/main/kotlin/app/git/diff/HunkDiffGenerator.kt

@@ -3,7 +3,6 @@ package app.git.diff
 import app.extensions.lineAt
 import app.git.EntryContent
 import app.git.RawFileManager
-import dagger.assisted.AssistedInject
 import org.eclipse.jgit.diff.*
 import org.eclipse.jgit.lib.Repository
 import org.eclipse.jgit.patch.FileHeader

src/main/kotlin/app/git/submodules/InitalizeSubmoduleUseCase.kt

@@ -0,0 +1,14 @@
+package app.git.submodules
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.eclipse.jgit.api.Git
+import javax.inject.Inject
+
+class InitializeSubmoduleUseCase @Inject constructor() {
+    suspend operator fun invoke(git: Git, path: String): Unit = withContext(Dispatchers.IO) {
+        git.submoduleInit()
+            .addPath(path)
+            .call()
+    }
+}

src/main/kotlin/app/git/submodules/UpdateSubmoduleUseCase.kt

@@ -0,0 +1,59 @@
+package app.git.submodules
+
+import app.logging.printLog
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.eclipse.jgit.api.CloneCommand
+import org.eclipse.jgit.api.Git
+import org.eclipse.jgit.lib.AnyObjectId
+import org.eclipse.jgit.lib.ProgressMonitor
+import javax.inject.Inject
+
+private const val TAG = "UpdateSubmoduleUseCase"
+
+class UpdateSubmoduleUseCase @Inject constructor() {
+    suspend operator fun invoke(git: Git, path: String) = withContext(Dispatchers.IO) {
+        git.submoduleUpdate()
+            .addPath(path)
+            .setCallback(
+                object : CloneCommand.Callback {
+                    override fun initializedSubmodules(submodules: MutableCollection<String>?) {
+
+                    }
+
+                    override fun cloningSubmodule(path: String?) {
+
+                    }
+
+                    override fun checkingOut(commit: AnyObjectId?, path: String?) {
+
+                    }
+
+                }
+            )
+            .setProgressMonitor(object: ProgressMonitor {
+                override fun start(totalTasks: Int) {
+                    printLog(TAG, "start $totalTasks")
+                }
+
+                override fun beginTask(title: String?, totalWork: Int) {
+                    printLog(TAG, "being task $title $totalWork")
+                }
+
+                override fun update(completed: Int) {
+                    printLog(TAG, "Completed $completed")
+                }
+
+                override fun endTask() {
+                    printLog(TAG, "endtask")
+                }
+
+                override fun isCancelled(): Boolean {
+                    printLog(TAG, "isCancelled")
+                    return false
+                }
+
+            })
+            .call()
+    }
+}

src/main/kotlin/app/ui/Submodules.kt

@@ -1,5 +1,6 @@
 package app.ui
 
+import androidx.compose.foundation.ContextMenuArea
 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.MaterialTheme
@@ -14,6 +15,7 @@ import app.theme.secondaryTextColor
 import app.ui.components.SideMenuPanel
 import app.ui.components.SideMenuSubentry
 import app.ui.components.Tooltip
+import app.ui.context_menu.submoduleContextMenuItems
 import app.viewmodels.SubmodulesViewModel
 import org.eclipse.jgit.submodule.SubmoduleStatus
 
@@ -34,6 +36,7 @@ fun Submodules(
         itemContent = { submodule ->
             SubmoduleLineEntry(
                 submodulePair = submodule,
+                onInitializeModule = { submodulesViewModel.initializeSubmodule(submodule.first) }
             )
         }
     )
@@ -43,20 +46,29 @@ fun Submodules(
 @Composable
 private fun SubmoduleLineEntry(
     submodulePair: Pair<String, SubmoduleStatus>,
+    onInitializeModule: () -> Unit,
 ) {
-    submodulePair.second.type
-    SideMenuSubentry(
-        text = submodulePair.first,
-        iconResourcePath = "topic.svg",
-    ) {
-        val stateName = submodulePair.second.type.toString()
-        Tooltip(stateName) {
-            Text(
-                text = stateName.first().toString(),
-                color = MaterialTheme.colors.secondaryTextColor,
-                style = MaterialTheme.typography.body2,
-                modifier = Modifier.padding(horizontal = 16.dp),
+    ContextMenuArea(
+        items = {
+            submoduleContextMenuItems(
+                submodulePair.second,
+                onInitializeModule = onInitializeModule
             )
         }
+    ) {
+        SideMenuSubentry(
+            text = submodulePair.first,
+            iconResourcePath = "topic.svg",
+        ) {
+            val stateName = submodulePair.second.type.toString()
+            Tooltip(stateName) {
+                Text(
+                    text = stateName.first().toString(),
+                    color = MaterialTheme.colors.secondaryTextColor,
+                    style = MaterialTheme.typography.body2,
+                    modifier = Modifier.padding(horizontal = 16.dp),
+                )
+            }
+        }
     }
 }

src/main/kotlin/app/ui/context_menu/SubmoduleContextMenu.kt

@@ -0,0 +1,23 @@
+package app.ui.context_menu
+
+import androidx.compose.foundation.ContextMenuItem
+import androidx.compose.foundation.ExperimentalFoundationApi
+import org.eclipse.jgit.submodule.SubmoduleStatus
+import org.eclipse.jgit.submodule.SubmoduleStatusType
+
+@OptIn(ExperimentalFoundationApi::class)
+fun submoduleContextMenuItems(
+    submoduleStatus: SubmoduleStatus,
+    onInitializeModule: () -> Unit,
+): List<ContextMenuItem> {
+    return mutableListOf<ContextMenuItem>().apply {
+        if (submoduleStatus.type == SubmoduleStatusType.UNINITIALIZED) {
+            add(
+                ContextMenuItem(
+                    label = "Initialize submodule",
+                    onClick = onInitializeModule
+                )
+            )
+        }
+    }
+}

src/main/kotlin/app/viewmodels/SubmodulesViewModel.kt

@@ -1,16 +1,22 @@
 package app.viewmodels
 
+import app.git.RefreshType
+import app.git.TabState
 import app.git.submodules.GetSubmodulesUseCase
+import app.git.submodules.InitializeSubmoduleUseCase
+import app.git.submodules.UpdateSubmoduleUseCase
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import org.eclipse.jgit.api.Git
-import org.eclipse.jgit.lib.Ref
 import org.eclipse.jgit.submodule.SubmoduleStatus
 import javax.inject.Inject
 
 class SubmodulesViewModel @Inject constructor(
-    private val getSubmodulesUseCase: GetSubmodulesUseCase
-): ExpandableViewModel() {
+    private val tabState: TabState,
+    private val getSubmodulesUseCase: GetSubmodulesUseCase,
+    private val initializeSubmoduleUseCase: InitializeSubmoduleUseCase,
+    private val updateSubmoduleUseCase: UpdateSubmoduleUseCase,
+) : ExpandableViewModel() {
     private val _submodules = MutableStateFlow<List<Pair<String, SubmoduleStatus>>>(listOf())
     val submodules: StateFlow<List<Pair<String, SubmoduleStatus>>>
         get() = _submodules
@@ -19,6 +25,14 @@ class SubmodulesViewModel @Inject constructor(
         _submodules.value = getSubmodulesUseCase(git).toList()
     }
 
+    fun initializeSubmodule(path: String) = tabState.safeProcessing(
+        showError = true,
+        refreshType = RefreshType.SUBMODULES,
+    ) { git ->
+        initializeSubmoduleUseCase(git, path)
+        updateSubmoduleUseCase(git, path)
+    }
+
     suspend fun refresh(git: Git) {
         loadSubmodules(git)
     }

src/main/rules.txt

@@ -0,0 +1,48 @@
+-dontobfuscate
+-allowaccessmodification
+-keepattributes SourceFile, LineNumberTable
+
+-keep class kotlin.** { *; }
+-keep class kotlinx.coroutines.** { *; }
+-keep class org.jetbrains.skia.** { *; }
+-keep class org.jetbrains.skiko.** { *; }
+-keep class androidx.compose.foundation.** { *; }
+
+-keep class MainKt {
+	public static void main();
+}
+
+-dontwarn org.apache.sshd.**
+-dontnote org.apache.sshd.**
+
+-dontwarn okio.**
+-dontnote okio.**
+
+-dontwarn okhttp3.**
+-dontnote okhttp3.**
+
+-dontwarn retrofit2.**
+-dontnote retrofit2.**
+
+-dontwarn kotlin.**
+-dontnote kotlin.**
+
+-dontwarn kotlinx.**
+-dontnote kotlinx.**
+
+-dontwarn org.slf4j.**
+-dontnote org.slf4j.**
+
+-dontwarn androidx.compose.**
+-dontnote androidx.compose.**
+-keep class !my.package.name.** { *; }
+
+
+-assumenosideeffects public class androidx.compose.runtime.ComposerKt {
+    void sourceInformation(androidx.compose.runtime.Composer,java.lang.String);
+    void sourceInformationMarkerStart(androidx.compose.runtime.Composer,int,java.lang.String);
+    void sourceInformationMarkerEnd(androidx.compose.runtime.Composer);
+}
+
+-ignorewarnings
+