Format code

src/main/scala/gitbucket/core/service/MergeService.scala

@@ -3,25 +3,26 @@ package gitbucket.core.service
 import gitbucket.core.model.Account
 import gitbucket.core.util.Directory._
 import gitbucket.core.util.SyntaxSugars._
-
 import org.eclipse.jgit.merge.MergeStrategy
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.transport.RefSpec
 import org.eclipse.jgit.errors.NoMergeBaseException
-import org.eclipse.jgit.lib.{ObjectId, CommitBuilder, PersonIdent, Repository}
+import org.eclipse.jgit.lib.{CommitBuilder, ObjectId, PersonIdent, Repository}
-import org.eclipse.jgit.revwalk.RevWalk
+import org.eclipse.jgit.revwalk.{RevCommit, RevWalk}
 
 trait MergeService {
   import MergeService._
+
   /**
    * Checks whether conflict will be caused in merging within pull request.
    * Returns true if conflict will be caused.
    */
   def checkConflict(userName: String, repositoryName: String, branch: String, issueId: Int): Boolean = {
     using(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
-      MergeCacheInfo(git, branch, issueId).checkConflict()
+      new MergeCacheInfo(git, branch, issueId).checkConflict()
     }
   }
+
   /**
    * Checks whether conflict will be caused in merging within pull request.
    * only cache check.
@@ -30,13 +31,15 @@ trait MergeService {
    */
   def checkConflictCache(userName: String, repositoryName: String, branch: String, issueId: Int): Option[Boolean] = {
     using(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
-      MergeCacheInfo(git, branch, issueId).checkConflictCache()
+      new MergeCacheInfo(git, branch, issueId).checkConflictCache()
     }
   }
+
   /** merge pull request */
   def mergePullRequest(git:Git, branch: String, issueId: Int, message:String, committer: PersonIdent): Unit = {
-    MergeCacheInfo(git, branch, issueId).merge(message, committer)
+    new MergeCacheInfo(git, branch, issueId).merge(message, committer)
   }
+
   /** fetch remote branch to my repository refs/pull/{issueId}/head */
   def fetchAsPullRequest(userName: String, repositoryName: String, requestUserName: String, requestRepositoryName: String, requestBranch:String, issueId:Int){
     using(Git.open(getRepositoryDir(userName, repositoryName))){ git =>
@@ -46,6 +49,7 @@ trait MergeService {
         .call
     }
   }
+
   /**
    * Checks whether conflict will be caused in merging. Returns true if conflict will be caused.
    */
@@ -81,6 +85,7 @@ trait MergeService {
       }
     }
   }
+
   /**
    * Checks whether conflict will be caused in merging. Returns true if conflict will be caused.
    */
@@ -102,7 +107,9 @@ trait MergeService {
   }
 
 }
+
 object MergeService{
+
   object Util{
     // return treeId
     def createMergeCommit(repository: Repository, treeId: ObjectId, committer: PersonIdent, message: String, parents: Seq[ObjectId]): ObjectId = {
@@ -119,6 +126,7 @@ object MergeService{
       inserter.close()
       mergeCommitId
     }
+
     def updateRefs(repository: Repository, ref: String, newObjectId: ObjectId, force: Boolean, committer: PersonIdent, refLogMessage: Option[String] = None): Unit = {
       // update refs
       val refUpdate = repository.updateRef(ref)
@@ -129,12 +137,16 @@ object MergeService{
       refUpdate.update()
     }
   }
-  case class MergeCacheInfo(git:Git, branch:String, issueId:Int){
+
-    val repository = git.getRepository
+  class MergeCacheInfo(git: Git, branch: String, issueId: Int){
-    val mergedBranchName = s"refs/pull/${issueId}/merge"
+
-    val conflictedBranchName = s"refs/pull/${issueId}/conflict"
+    private val repository = git.getRepository
+    private val mergedBranchName = s"refs/pull/${issueId}/merge"
+    private val conflictedBranchName = s"refs/pull/${issueId}/conflict"
+
     lazy val mergeBaseTip = repository.resolve(s"refs/heads/${branch}")
     lazy val mergeTip = repository.resolve(s"refs/pull/${issueId}/head")
+
     def checkConflictCache(): Option[Boolean] = {
       Option(repository.resolve(mergedBranchName)).flatMap { merged =>
         if(parseCommit(merged).getParents().toSet == Set( mergeBaseTip, mergeTip )){
@@ -152,9 +164,11 @@ object MergeService{
         }
       })
     }
+
     def checkConflict(): Boolean = {
       checkConflictCache.getOrElse(checkConflictForce)
     }
+
     def checkConflictForce(): Boolean = {
       val merger = MergeStrategy.RECURSIVE.newMerger(repository, true)
       val conflicted = try {
@@ -164,11 +178,13 @@ object MergeService{
       }
       val mergeTipCommit = using(new RevWalk( repository ))(_.parseCommit( mergeTip ))
       val committer = mergeTipCommit.getCommitterIdent
+
       def updateBranch(treeId: ObjectId, message: String, branchName: String){
         // creates merge commit
         val mergeCommitId = createMergeCommit(treeId, committer, message)
         Util.updateRefs(repository, branchName, mergeCommitId, true, committer)
       }
+
       if(!conflicted){
         updateBranch(merger.getResultTreeId, s"Merge ${mergeTip.name} into ${mergeBaseTip.name}", mergedBranchName)
         git.branchDelete().setForce(true).setBranchNames(conflictedBranchName).call()
@@ -178,21 +194,26 @@ object MergeService{
       }
       conflicted
     }
+
     // update branch from cache
     def merge(message: String, committer: PersonIdent) = {
       if(checkConflict()){
         throw new RuntimeException("This pull request can't merge automatically.")
       }
-      val mergeResultCommit = parseCommit( Option(repository.resolve(mergedBranchName)).getOrElse(throw new RuntimeException(s"not found branch ${mergedBranchName}")) )
+      val mergeResultCommit = parseCommit(Option(repository.resolve(mergedBranchName)).getOrElse {
+        throw new RuntimeException(s"not found branch ${mergedBranchName}")
+      })
       // creates merge commit
       val mergeCommitId = createMergeCommit(mergeResultCommit.getTree().getId(), committer, message)
       // update refs
       Util.updateRefs(repository, s"refs/heads/${branch}", mergeCommitId, false, committer, Some("merged"))
     }
+
     // return treeId
     private def createMergeCommit(treeId: ObjectId, committer: PersonIdent, message: String) =
       Util.createMergeCommit(repository, treeId, committer, message, Seq[ObjectId](mergeBaseTip, mergeTip))
 
     private def parseCommit(id:ObjectId) = using(new RevWalk( repository ))(_.parseCommit(id))
+
   }
 }