Added stashes visualitzation in the graph

JetpackDuba · JetpackDuba · commit 61088c48b4ae · 2025-05-03T22:35:15.000+02:00
Fixes #134
diff --git a/src/main/kotlin/com/jetpackduba/gitnuro/git/graph/GraphCommitList.kt b/src/main/kotlin/com/jetpackduba/gitnuro/git/graph/GraphCommitList.kt
@@ -1,11 +1,7 @@
 package com.jetpackduba.gitnuro.git.graph
 
-import org.eclipse.jgit.internal.JGitText
 import org.eclipse.jgit.lib.AnyObjectId
 import org.eclipse.jgit.revwalk.RevCommit
-import org.eclipse.jgit.revwalk.RevCommitList
-import org.eclipse.jgit.revwalk.RevWalk
-import java.text.MessageFormat
 import java.util.*
 
 /**
@@ -21,11 +17,18 @@ import java.util.*
  *
  * type of lane used by the application.
 </L> */
-class GraphCommitList : RevCommitList<GraphNode>() {
+class GraphCommitList(
+    private val commits: MutableList<GraphNode> = mutableListOf(),
+) : MutableList<GraphNode> by commits {
+    var walker: GraphWalk? = null
     private var positionsAllocated = 0
     private val freePositions = TreeSet<Int>()
     private val activeLanes = HashSet<GraphLane>(32)
 
+    private var parentId: AnyObjectId? = null
+
+    private val graphCommit = UncommittedChangesGraphNode()
+
     var maxLine = 0
         private set
 
@@ -35,34 +38,48 @@ class GraphCommitList : RevCommitList<GraphNode>() {
     )
 
     override fun clear() {
-        super.clear()
         positionsAllocated = 0
         freePositions.clear()
         activeLanes.clear()
         laneLength.clear()
+        commits.clear()
     }
 
-    override fun source(revWalk: RevWalk) {
-        if (revWalk !is GraphWalk) throw ClassCastException(
-            MessageFormat.format(
-                JGitText.get().classCastNotA,
-                GraphWalk::class.java.name
-            )
-        )
+    fun fillTo(highMark: Int) {
+        if (this.size <= highMark) {
+            var c: GraphNode? = null
+
+            do {
+                c = this.walker?.next()
+
+                if (c != null) {
+                    val stashChild = c.children.firstOrNull { it.isStash }
+
+                    if (
+                        stashChild == null ||
+                        (
+                                stashChild.parentCount > 0 &&
+                                        stashChild.parents[0] == c
+                                )
+                    ) {
+                        this.enter(this.size, c)
+                        this.add(c)
+                    }
+                }
+            } while (c != null && size <= highMark)
 
-        super.source(revWalk)
+            if (c == null) {
+                this.walker = null
+            }
+        }
     }
 
-    private var parentId: AnyObjectId? = null
-
-    private val graphCommit = UncommittedChangesGraphNode()
-
     fun addUncommittedChangesGraphCommit(parent: RevCommit) {
         parentId = parent.id
         graphCommit.lane = nextFreeLane()
     }
 
-    override fun enter(index: Int, currCommit: GraphNode) {
+    fun enter(index: Int, currCommit: GraphNode) {
         var isUncommittedChangesNodeParent = false
         if (currCommit.id == parentId) {
             graphCommit.graphParent = currCommit
@@ -113,19 +130,18 @@ class GraphCommitList : RevCommitList<GraphNode>() {
                 }
             } else {
                 val children = currCommit.children.sortedBy { it.lane.position }
-                for (i in 0 until nChildren) {
-                    val c: GraphNode = children[i]
-                    if (c.getGraphParent(0) === currCommit) {
-                        if (c.lane.position < 0)
-                            println("c.lane.position is invalid (${c.lane.position})")
+                for (child in children) {
+                    if (child.getGraphParent(0) === currCommit) {
+                        if (child.lane.position < 0)
+                            println("child.lane.position is invalid (${child.lane.position})")
 
-                        val length = laneLength[c.lane]
+                        val length = laneLength[child.lane]
 
                         // we may be the first parent for multiple lines of
                         // development, try to continue the longest one
                         if (length != null && length > lengthOfReservedLane) {
-                            reservedLane = c.lane
-                            childOnReservedLane = c
+                            reservedLane = child.lane
+                            childOnReservedLane = child
                             lengthOfReservedLane = length
 
                             break
@@ -156,9 +172,17 @@ class GraphCommitList : RevCommitList<GraphNode>() {
 
         continueActiveLanes(currCommit)
 
-        if (currCommit.parentCount == 0 && currCommit.lane.position == INVALID_LANE_POSITION)
+        if (currCommit.parentCount == 0 && currCommit.lane.position == INVALID_LANE_POSITION) {
             closeLane(currCommit.lane)
+        }
 
+        if (
+            currCommit.childCount == 1 &&
+            currCommit.children.first().isStash &&
+            currCommit.parentCount == 0
+        ) {
+            closeLane(currCommit.lane)
+        }
     }
 
     private fun continueActiveLanes(currCommit: GraphNode) {
@@ -182,7 +206,8 @@ class GraphCommitList : RevCommitList<GraphNode>() {
      * the lane
      */
     private fun handleBlockedLanes(
-        index: Int, currentNode: GraphNode,
+        index: Int,
+        currentNode: GraphNode,
         childOnLane: GraphNode?,
     ) {
         for (child in currentNode.children) {
@@ -211,8 +236,11 @@ class GraphCommitList : RevCommitList<GraphNode>() {
 
     // Handles the case where currCommit is a non-first parent of the child
     private fun handleMerge(
-        index: Int, currCommit: GraphNode,
-        childOnLane: GraphNode?, child: GraphNode, laneToUse: GraphLane,
+        index: Int,
+        currCommit: GraphNode,
+        childOnLane: GraphNode?,
+        child: GraphNode,
+        laneToUse: GraphLane,
     ): GraphLane {
 
         // find all blocked positions between currCommit and this child
@@ -302,8 +330,9 @@ class GraphCommitList : RevCommitList<GraphNode>() {
     }
 
     private fun setupChildren(currCommit: GraphNode) {
-        val nParents = currCommit.parentCount
-        for (i in 0 until nParents) (currCommit.getParent(i) as GraphNode).addChild(currCommit)
+        for (parent in currCommit.parents) {
+            (parent as GraphNode).addChild(currCommit)
+        }
     }
 
     private fun nextFreeLane(blockedPositions: BitSet? = null): GraphLane {
@@ -363,4 +392,4 @@ class GraphCommitList : RevCommitList<GraphNode>() {
             maxLine = this.maxOf { it.lane.position }
         }
     }
-}
+}
diff --git a/src/main/kotlin/com/jetpackduba/gitnuro/git/graph/GraphWalk.kt b/src/main/kotlin/com/jetpackduba/gitnuro/git/graph/GraphWalk.kt
@@ -15,6 +15,7 @@ import java.io.IOException
 class GraphWalk(private var repository: Repository?) : RevWalk(repository) {
     private var additionalRefMap: MutableMap<AnyObjectId, Set<Ref>>? = HashMap()
     private var reverseRefMap: MutableMap<AnyObjectId, Set<Ref>>? = null
+    private var stashes = emptySet<AnyObjectId>()
 
     init {
         super.sort(RevSort.TOPO, true)
@@ -45,17 +46,18 @@ class GraphWalk(private var repository: Repository?) : RevWalk(repository) {
         return GraphNode(id)
     }
 
-    override fun next(): RevCommit? {
+    override fun next(): GraphNode? {
         val graphNode = super.next() as GraphNode?
 
         if (graphNode != null) {
             val refs = getRefs(graphNode)
-
-            graphNode.isStash = refs.count() == 1 && refs.firstOrNull()?.name == "refs/stash"
             graphNode.refs = refs
+
+            graphNode.isStash = stashes.contains(graphNode)
         }
 
         return graphNode
+
     }
 
     private fun getRefs(commitId: AnyObjectId): List<Ref> {
@@ -102,14 +104,14 @@ class GraphWalk(private var repository: Repository?) : RevWalk(repository) {
         repository?.let { repo ->
             for (ref in repo.refDatabase.getRefsByPrefix(prefix)) {
                 if (ref.isSymbolic) continue
-                markStartRef(ref)
+                markStartObjectId(ref.leaf.objectId)
             }
         }
     }
 
-    private fun markStartRef(ref: Ref) {
+    private fun markStartObjectId(objectId: AnyObjectId) {
         try {
-            val refTarget = parseAny(ref.leaf.objectId)
+            val refTarget = parseAny(objectId)
 
             when (refTarget) {
                 is RevCommit -> markStart(refTarget)
@@ -128,6 +130,17 @@ class GraphWalk(private var repository: Repository?) : RevWalk(repository) {
         }
     }
 
+    fun markStartStashes(stashList: List<RevCommit>) {
+        for (stash in stashList) {
+            markStartObjectId(stash)
+        }
+
+        this.stashes = stashList
+            .asSequence()
+            .map { it.toObjectId() }
+            .toSet()
+    }
+
     internal inner class GraphRefComparator : Comparator<Ref> {
         override fun compare(o1: Ref, o2: Ref): Int {
             try {
diff --git a/src/main/kotlin/com/jetpackduba/gitnuro/git/log/GetLogUseCase.kt b/src/main/kotlin/com/jetpackduba/gitnuro/git/log/GetLogUseCase.kt
@@ -3,18 +3,18 @@ package com.jetpackduba.gitnuro.git.log
 
 import com.jetpackduba.gitnuro.git.graph.GraphCommitList
 import com.jetpackduba.gitnuro.git.graph.GraphWalk
+import com.jetpackduba.gitnuro.git.stash.GetStashListUseCase
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.withContext
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.lib.Constants
 import org.eclipse.jgit.lib.Ref
-import org.eclipse.jgit.lib.Repository
 import javax.inject.Inject
 
-class GetLogUseCase @Inject constructor() {
-    private var graphWalkCached: GraphWalk? = null
-
+class GetLogUseCase @Inject constructor(
+    private val getStashListUseCase: GetStashListUseCase,
+) {
     suspend operator fun invoke(
         git: Git,
         currentBranch: Ref?,
@@ -23,50 +23,38 @@ class GetLogUseCase @Inject constructor() {
         cachedCommitList: GraphCommitList? = null,
     ) = withContext(Dispatchers.IO) {
         val repositoryState = git.repository.repositoryState
-        val commitList: GraphCommitList = cachedCommitList ?: GraphCommitList()
-
+        val commitList = cachedCommitList ?: GraphCommitList()
         if (currentBranch != null || repositoryState.isRebasing) { // Current branch is null when there is no log (new repo) or rebasing
             val logList = git.log().setMaxCount(1).call().toList()
 
-            val walk = GraphWalk(git.repository)
+            if (cachedCommitList == null) {
+                val walk = GraphWalk(git.repository)
 
-            walk.use {
-                // Without this, during rebase conflicts the graph won't show the HEAD commits (new commits created
-                // by the rebase)
-                if (cachedCommitList == null) {
+                walk.use {
+                    // Without this, during rebase conflicts the graph won't show the HEAD commits (new commits created
+                    // by the rebase)
                     walk.markStart(walk.lookupCommit(logList.first()))
 
                     walk.markStartAllRefs(Constants.R_HEADS)
                     walk.markStartAllRefs(Constants.R_REMOTES)
                     walk.markStartAllRefs(Constants.R_TAGS)
+                    walk.markStartStashes(getStashListUseCase(git))
 
-                    if (hasUncommittedChanges)
+                    if (hasUncommittedChanges) {
                         commitList.addUncommittedChangesGraphCommit(logList.first())
-//                    val count = walk.count()
-//                    println("Commits list count is $count")
-                    commitList.source(walk)
+                    }
+
+                    commitList.walker = walk
                 }
-                commitList.fillTo(commitsLimit)
             }
 
+            commitList.fillTo(commitsLimit)
+
             ensureActive()
         }
 
         commitList.calcMaxLine()
 
         return@withContext commitList
     }
-
-    private fun cachedGraphWalk(repository: Repository): GraphWalk {
-        val graphWalkCached = this.graphWalkCached
-
-        return if (graphWalkCached != null) {
-            graphWalkCached
-        } else {
-            val newGraphWalk = GraphWalk(repository)
-            this.graphWalkCached = newGraphWalk
-
-            newGraphWalk
-        }
-    }
 }
diff --git a/src/main/kotlin/com/jetpackduba/gitnuro/ui/log/Log.kt b/src/main/kotlin/com/jetpackduba/gitnuro/ui/log/Log.kt
@@ -60,10 +60,7 @@ import com.jetpackduba.gitnuro.ui.dialogs.NewTagDialog
 import com.jetpackduba.gitnuro.ui.dialogs.ResetBranchDialog
 import com.jetpackduba.gitnuro.ui.dialogs.SetDefaultUpstreamBranchDialog
 import com.jetpackduba.gitnuro.ui.resizePointerIconEast
-import com.jetpackduba.gitnuro.viewmodels.ChangeUpstreamBranchDialogViewModel
-import com.jetpackduba.gitnuro.viewmodels.LogSearch
-import com.jetpackduba.gitnuro.viewmodels.LogStatus
-import com.jetpackduba.gitnuro.viewmodels.LogViewModel
+import com.jetpackduba.gitnuro.viewmodels.*
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.launch
 import org.eclipse.jgit.lib.Ref
@@ -96,7 +93,7 @@ private const val DIVIDER_WIDTH = 8
 
 private const val LOG_BOTTOM_PADDING = 80
 
-private const val MIN_COMMITS_BEFORE_REQUESTING_MORE = 100
+private const val MIN_COMMITS_BEFORE_REQUESTING_MORE = INCREMENTAL_COMMITS_LOAD
 
 private const val TAG = "LogView"
 
diff --git a/src/main/kotlin/com/jetpackduba/gitnuro/viewmodels/LogViewModel.kt b/src/main/kotlin/com/jetpackduba/gitnuro/viewmodels/LogViewModel.kt
@@ -50,8 +50,8 @@ private const val FIRST_INDEX = 1
 
 private const val LOG_MIN_TIME_IN_MS_TO_SHOW_LOAD = 500L
 
-private const val INITIAL_COMMITS_LOAD = 4000
-private const val INCREMENTAL_COMMITS_LOAD = 1000
+private const val INITIAL_COMMITS_LOAD = 2000
+const val INCREMENTAL_COMMITS_LOAD = 1000
 
 class LogViewModel @Inject constructor(
     private val getLogUseCase: GetLogUseCase,
