(refs #2)Fix comparing diffs before sending pull request.

src/main/scala/app/PullRequestsController.scala

@@ -109,12 +109,16 @@ trait PullRequestsControllerBase extends ControllerBase {
       val git = Git.cloneRepository.setDirectory(tmpdir).setURI(remote.toURI.toString).call
 
       try {
-        val (commits, diffs) = getCompareInfo(repository.owner, repository.name, pullreq.branch,
+        val (commits, _) = getCompareInfo(repository.owner, repository.name, pullreq.branch,
                                   pullreq.requestUserName, pullreq.requestRepositoryName, pullreq.requestBranch)
         mergePullRequest(repository.owner, repository.name, issueId,
           git.getRepository.resolve("master").getName,
           commits.head.head.id)
 
+        commits.flatten.foreach { commit =>
+          insertCommitId(repository.owner, repository.name, commit.id)
+        }
+
         // TODO mark issue as 'merged'
         val loginAccount = context.loginAccount.get
         createComment(repository.owner, repository.name, loginAccount.userName, issueId, "Closed", Some("close"))
@@ -235,16 +239,10 @@ trait PullRequestsControllerBase extends ControllerBase {
       getRepositoryDir(userName, repositoryName),
       getRepositoryDir(requestUserName, requestRepositoryName)
     ){ (oldGit, newGit) =>
-      val oldReader = oldGit.getRepository.newObjectReader
-      val oldTreeIter = new CanonicalTreeParser
-      oldTreeIter.reset(oldReader, oldGit.getRepository.resolve(s"${branch}^{tree}"))
-
-      val newReader = newGit.getRepository.newObjectReader
-      val newTreeIter = new CanonicalTreeParser
-      newTreeIter.reset(newReader, newGit.getRepository.resolve(s"${requestBranch}^{tree}"))
-
-      val oldId = oldGit.getRepository.resolve(branch)
       val newId = newGit.getRepository.resolve(requestBranch)
+      val oldId = newGit.getRepository.resolve(JGitUtil.getCommitLogFrom(newGit, newId.getName, true){ revCommit =>
+        existsCommitId(userName, repositoryName, revCommit.getName)
+      }.head.id)
 
       val commits = newGit.log.addRange(oldId, newId).call.iterator.asScala.map { revCommit =>
         new CommitInfo(revCommit)
@@ -252,15 +250,7 @@ trait PullRequestsControllerBase extends ControllerBase {
         view.helpers.date(commit1.time) == view.helpers.date(commit2.time)
       }
 
-      val diffs = newGit.diff.setOldTree(oldTreeIter).setNewTree(newTreeIter).call.asScala.map { diff =>
+      val diffs = JGitUtil.getDiffs(newGit, oldId.getName, newId.getName, true)
-        if(FileUtil.isImage(diff.getOldPath) || FileUtil.isImage(diff.getNewPath)){
-          DiffInfo(diff.getChangeType, diff.getOldPath, diff.getNewPath, None, None)
-        } else {
-          DiffInfo(diff.getChangeType, diff.getOldPath, diff.getNewPath,
-            JGitUtil.getContent(oldGit, diff.getOldId.toObjectId, false).filter(FileUtil.isText).map(new String(_, "UTF-8")),
-            JGitUtil.getContent(newGit, diff.getNewId.toObjectId, false).filter(FileUtil.isText).map(new String(_, "UTF-8")))
-        }
-      }.toSeq
 
       (commits, diffs)
     }

src/main/scala/app/WikiController.scala

@@ -59,7 +59,7 @@ trait WikiControllerBase extends ControllerBase {
     val commitId = params("commitId").split("\\.\\.\\.")
 
     JGitUtil.withGit(getWikiRepositoryDir(repository.owner, repository.name)){ git =>
-      wiki.html.compare(Some(pageName), getWikiDiffs(git, commitId(0), commitId(1)), repository)
+      wiki.html.compare(Some(pageName), JGitUtil.getDiffs(git, commitId(0), commitId(1), true), repository)
     }
   })
   
@@ -67,7 +67,7 @@ trait WikiControllerBase extends ControllerBase {
     val commitId   = params("commitId").split("\\.\\.\\.")
 
     JGitUtil.withGit(getWikiRepositoryDir(repository.owner, repository.name)){ git =>
-      wiki.html.compare(None, getWikiDiffs(git, commitId(0), commitId(1)), repository)
+      wiki.html.compare(None, JGitUtil.getDiffs(git, commitId(0), commitId(1), true), repository)
     }
   })
   

src/main/scala/service/WikiService.scala

@@ -187,27 +187,6 @@ trait WikiService {
     }
   }
 
-  /**
-   * Returns differences between specified commits.
-   */
-  def getWikiDiffs(git: Git, commitId1: String, commitId2: String): List[DiffInfo] = {
-      // get diff between specified commit and its previous commit
-      val reader = git.getRepository.newObjectReader
-      
-      val oldTreeIter = new CanonicalTreeParser
-      oldTreeIter.reset(reader, git.getRepository.resolve(commitId1 + "^{tree}"))
-      
-      val newTreeIter = new CanonicalTreeParser
-      newTreeIter.reset(reader, git.getRepository.resolve(commitId2 + "^{tree}"))
-      
-      import scala.collection.JavaConverters._
-      git.diff.setNewTree(newTreeIter).setOldTree(oldTreeIter).call.asScala.map { diff =>
-        DiffInfo(diff.getChangeType, diff.getOldPath, diff.getNewPath,
-            JGitUtil.getContent(git, diff.getOldId.toObjectId, false).map(new String(_, "UTF-8")), 
-            JGitUtil.getContent(git, diff.getNewId.toObjectId, false).map(new String(_, "UTF-8")))
-      }.toList
-  }
-
   private def cloneOrPullWorkingCopy(workDir: File, owner: String, repository: String): Unit = {
     if(!workDir.exists){
       Git.cloneRepository

src/main/scala/util/JGitUtil.scala

@@ -283,6 +283,31 @@ object JGitUtil {
       Right(commits)
     }
   }
+
+  def getCommitLogFrom(git: Git, to: String, containsLast: Boolean = false)(from: RevCommit => Boolean): List[CommitInfo] = {
+    @scala.annotation.tailrec
+    def getCommitLog(i: java.util.Iterator[RevCommit], logs: List[CommitInfo]): List[CommitInfo] =
+      i.hasNext match {
+        case true  => {
+          val revCommit = i.next
+          if(from(revCommit)){
+            if(containsLast) logs :+ new CommitInfo(revCommit) else logs
+          } else {
+            getCommitLog(i, logs :+ new CommitInfo(revCommit))
+          }
+        }
+        case false => logs
+      }
+
+    val revWalk = new RevWalk(git.getRepository)
+    revWalk.markStart(revWalk.parseCommit(git.getRepository.resolve(to)))
+
+    val commits = getCommitLog(revWalk.iterator, Nil)
+    revWalk.release
+
+    commits.reverse
+  }
+
   
   /**
    * Returns the commit list between two revisions.
@@ -292,30 +317,8 @@ object JGitUtil {
    * @param to the to revision
    * @return the commit list
    */
-  def getCommitLog(git: Git, from: String, to: String): List[CommitInfo] = {
+  def getCommitLog(git: Git, from: String, to: String): List[CommitInfo] =
-    @scala.annotation.tailrec
+    getCommitLogFrom(git, from)(_.getName == from)
-    def getCommitLog(i: java.util.Iterator[RevCommit], logs: List[CommitInfo]): List[CommitInfo] =
-      i.hasNext match {
-        case true  => {
-          val revCommit = i.next
-          if(revCommit.name == from){
-            logs 
-          } else {
-            getCommitLog(i, logs :+ new CommitInfo(revCommit))
-          }
-        }
-        case false => logs
-      }
-    
-    val revWalk = new RevWalk(git.getRepository)
-    revWalk.markStart(revWalk.parseCommit(git.getRepository.resolve(to)))
-    
-    val commits = getCommitLog(revWalk.iterator, Nil)
-    revWalk.release
-    
-    commits.reverse
-  }
-  
   
   /**
    * Returns the latest RevCommit of the specified path.
@@ -427,26 +430,8 @@ object JGitUtil {
     if(commits.length >= 2){
       // not initial commit
       val oldCommit = commits(1)
-      
+      getDiffs(git, oldCommit.getName, id, fetchContent)
-      // get diff between specified commit and its previous commit
+
-      val reader = git.getRepository.newObjectReader
-      
-      val oldTreeIter = new CanonicalTreeParser
-      oldTreeIter.reset(reader, git.getRepository.resolve(oldCommit.name + "^{tree}"))
-      
-      val newTreeIter = new CanonicalTreeParser
-      newTreeIter.reset(reader, git.getRepository.resolve(id + "^{tree}"))
-      
-      import scala.collection.JavaConverters._
-      git.diff.setNewTree(newTreeIter).setOldTree(oldTreeIter).call.asScala.map { diff =>
-        if(!fetchContent || FileUtil.isImage(diff.getOldPath) || FileUtil.isImage(diff.getNewPath)){
-          DiffInfo(diff.getChangeType, diff.getOldPath, diff.getNewPath, None, None)
-        } else {
-          DiffInfo(diff.getChangeType, diff.getOldPath, diff.getNewPath,
-            JGitUtil.getContent(git, diff.getOldId.toObjectId, false).filter(FileUtil.isText).map(new String(_, "UTF-8")),
-            JGitUtil.getContent(git, diff.getNewId.toObjectId, false).filter(FileUtil.isText).map(new String(_, "UTF-8")))
-        }
-      }.toList
     } else {
       // initial commit
       val walk = new TreeWalk(git.getRepository)
@@ -465,6 +450,27 @@ object JGitUtil {
     }
   }
 
+  def getDiffs(git: Git, from: String, to: String, fetchContent: Boolean): List[DiffInfo] = {
+    val reader = git.getRepository.newObjectReader
+    val oldTreeIter = new CanonicalTreeParser
+    oldTreeIter.reset(reader, git.getRepository.resolve(from + "^{tree}"))
+
+    val newTreeIter = new CanonicalTreeParser
+    newTreeIter.reset(reader, git.getRepository.resolve(to + "^{tree}"))
+
+    import scala.collection.JavaConverters._
+    git.diff.setNewTree(newTreeIter).setOldTree(oldTreeIter).call.asScala.map { diff =>
+      if(!fetchContent || FileUtil.isImage(diff.getOldPath) || FileUtil.isImage(diff.getNewPath)){
+        DiffInfo(diff.getChangeType, diff.getOldPath, diff.getNewPath, None, None)
+      } else {
+        DiffInfo(diff.getChangeType, diff.getOldPath, diff.getNewPath,
+          JGitUtil.getContent(git, diff.getOldId.toObjectId, false).filter(FileUtil.isText).map(new String(_, "UTF-8")),
+          JGitUtil.getContent(git, diff.getNewId.toObjectId, false).filter(FileUtil.isText).map(new String(_, "UTF-8")))
+      }
+    }.toList
+  }
+
+
   /**
    * Returns the list of branch names of the specified commit.
    */