Use ControlUtil.

src/main/scala/app/PullRequestsController.scala

@@ -208,9 +208,9 @@ trait PullRequestsControllerBase extends ControllerBase {
     (forkedRepository.repository.originUserName, forkedRepository.repository.originRepositoryName) match {
       case (Some(originUserName), Some(originRepositoryName)) => {
         getRepository(originUserName, originRepositoryName, baseUrl).map { originRepository =>
-          withGit(
-            getRepositoryDir(originUserName, originRepositoryName),
-            getRepositoryDir(forkedRepository.owner, forkedRepository.name)
+          using(
+            Git.open(getRepositoryDir(originUserName, originRepositoryName)),
+            Git.open(getRepositoryDir(forkedRepository.owner, forkedRepository.name))
           ){ (oldGit, newGit) =>
             val oldBranch = JGitUtil.getDefaultBranch(oldGit, originRepository).get._2
             val newBranch = JGitUtil.getDefaultBranch(newGit, forkedRepository).get._2
@@ -236,9 +236,9 @@ trait PullRequestsControllerBase extends ControllerBase {
     (getRepository(originOwner, repository.name, baseUrl),
      getRepository(forkedOwner,   repository.name, baseUrl)) match {
       case (Some(originRepository), Some(forkedRepository)) => {
-        withGit(
-          getRepositoryDir(originOwner, repository.name),
-          getRepositoryDir(forkedOwner,   repository.name)
+        using(
+          Git.open(getRepositoryDir(originOwner, repository.name)),
+          Git.open(getRepositoryDir(forkedOwner,   repository.name))
         ){ case (oldGit, newGit) =>
           val originBranch = JGitUtil.getDefaultBranch(oldGit, originRepository, tmpOriginBranch).get._2
           val forkedBranch = JGitUtil.getDefaultBranch(newGit, forkedRepository, tmpForkedBranch).get._2
@@ -318,20 +318,6 @@ trait PullRequestsControllerBase extends ControllerBase {
     redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}")
   })
 
-  /**
-   * Handles w Git object simultaneously.
-   */
-  private def withGit[T](oldDir: java.io.File, newDir: java.io.File)(action: (Git, Git) => T): T = {
-    val oldGit = Git.open(oldDir)
-    val newGit = Git.open(newDir)
-    try {
-      action(oldGit, newGit)
-    } finally {
-      oldGit.getRepository.close
-      newGit.getRepository.close
-    }
-  }
-
   /**
    * Parses branch identifier and extracts owner and branch name as tuple.
    *
@@ -365,9 +351,9 @@ trait PullRequestsControllerBase extends ControllerBase {
   private def getRequestCompareInfo(userName: String, repositoryName: String, branch: String,
       requestUserName: String, requestRepositoryName: String, requestCommitId: String): (Seq[Seq[CommitInfo]], Seq[DiffInfo]) = {
 
-    withGit(
-      getRepositoryDir(userName, repositoryName),
-      getRepositoryDir(requestUserName, requestRepositoryName)
+    using(
+      Git.open(getRepositoryDir(userName, repositoryName)),
+      Git.open(getRepositoryDir(requestUserName, requestRepositoryName))
     ){ (oldGit, newGit) =>
       val oldId = oldGit.getRepository.resolve(branch)
       val newId = newGit.getRepository.resolve(requestCommitId)
@@ -384,9 +370,8 @@ trait PullRequestsControllerBase extends ControllerBase {
     }
   }
 
-  private def searchPullRequests(userName: Option[String], repository: RepositoryService.RepositoryInfo) = {
-    val owner      = repository.owner
-    val repoName   = repository.name
+  private def searchPullRequests(userName: Option[String], repository: RepositoryService.RepositoryInfo) =
+    defining(repository.owner, repository.name){ case (owner, repoName) =>
       val filterUser = userName.map { x => Map("created_by" -> x) } getOrElse Map("all" -> "")
       val page       = IssueSearchCondition.page(request)
       val sessionKey = s"${owner}/${repoName}/pulls"

src/main/scala/app/RepositorySettingsController.scala

@@ -180,8 +180,8 @@ trait RepositorySettingsControllerBase extends ControllerBase with FlashMapSuppo
    * Provides duplication check for web hook url.
    */
   private def webHook: Constraint = new Constraint(){
-    override def validate(name: String, value: String): Option[String] = {
-      val paths = request.getRequestURI.split("/")
+    override def validate(name: String, value: String): Option[String] =
+      defining(request.getRequestURI.split("/")){ paths =>
         getWebHookURLs(paths(1), paths(2)).map(_.url).find(_ == value).map(_ => "URL had been registered already.")
       }
   }
@@ -190,8 +190,8 @@ trait RepositorySettingsControllerBase extends ControllerBase with FlashMapSuppo
    * Provides Constraint to validate the collaborator name.
    */
   private def collaborator: Constraint = new Constraint(){
-    override def validate(name: String, value: String): Option[String] = {
-      val paths = request.getRequestURI.split("/")
+    override def validate(name: String, value: String): Option[String] =
+      defining(request.getRequestURI.split("/")){ paths =>
         getAccountByUserName(value) match {
           case None => Some("User does not exist.")
           case Some(x) if(x.userName == paths(1) || getCollaborators(paths(1), paths(2)).contains(x.userName))

src/main/scala/app/RepositoryViewerController.scala

@@ -85,13 +85,10 @@ trait RepositoryViewerControllerBase extends ControllerBase {
         case true => getPathObjectId(path, walk)
       }
 
-      val treeWalk = new TreeWalk(git.getRepository)
-      val objectId = try {
+      val objectId = using(new TreeWalk(git.getRepository)){ treeWalk =>
         treeWalk.addTree(revCommit.getTree)
         treeWalk.setRecursive(true)
         getPathObjectId(path, treeWalk)
-      } finally {
-        treeWalk.release
       }
 
       if(raw){
@@ -129,8 +126,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
     val id = params("id")
 
     using(Git.open(getRepositoryDir(repository.owner, repository.name))){ git =>
-      val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))
-
+      defining(JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))){ revCommit =>
         JGitUtil.getDiffs(git, id) match { case (diffs, oldCommitId) =>
           repo.html.commit(id, new JGitUtil.CommitInfo(revCommit),
             JGitUtil.getBranchesOfCommit(git, revCommit.getName),
@@ -138,6 +134,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
             repository, diffs, oldCommitId)
         }
       }
+    }
   })
   
   /**
@@ -238,8 +235,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
         val revisions = Seq(if(revstr.isEmpty) repository.repository.defaultBranch else revstr, repository.branchList.head)
         // get specified commit
         JGitUtil.getDefaultBranch(git, repository, revstr).map { case (objectId, revision) =>
-          val revCommit = JGitUtil.getRevCommitFromId(git, objectId)
-
+          defining(JGitUtil.getRevCommitFromId(git, objectId)){ revCommit =>
           // get files
             val files = JGitUtil.getFileList(git, revision, path)
             // process README.md
@@ -251,6 +247,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
               if(path == ".") Nil else path.split("/").toList, // current path
               new JGitUtil.CommitInfo(revCommit), // latest commit
               files, readme)
+          }
         } getOrElse NotFound
       }
     }

src/main/scala/util/ControlUtil.scala

@@ -1,7 +1,8 @@
 package util
 
 import org.eclipse.jgit.api.Git
-import org.eclipse.jgit.revwalk.DepthWalk.RevWalk
+import org.eclipse.jgit.revwalk.RevWalk
+import org.eclipse.jgit.treewalk.TreeWalk
 
 /**
  * Provides control facilities.
@@ -11,9 +12,7 @@ object ControlUtil {
   def defining[A, B](value: A)(f: A => B): B = f(value)
 
   def using[A <% { def close(): Unit }, B](resource: A)(f: A => B): B =
-    try {
-      f(resource)
-    } finally {
+    try f(resource) finally {
       if(resource != null){
         try {
           resource.close()
@@ -24,31 +23,26 @@ object ControlUtil {
     }
 
   def using[T](git: Git)(f: Git => T): T =
-    try {
-      f(git)
-    } finally {
-      git.getRepository.close
+    try f(git) finally git.getRepository.close
+
+  def using[T](git1: Git, git2: Git)(f: (Git, Git) => T): T =
+    try f(git1, git2) finally {
+      git1.getRepository.close
+      git2.getRepository.close
     }
 
   def using[T](revWalk: RevWalk)(f: RevWalk => T): T =
-    try {
-      f(revWalk)
-    } finally {
-      revWalk.release()
-    }
+    try f(revWalk) finally revWalk.release()
+
+  def using[T](treeWalk: TreeWalk)(f: TreeWalk => T): T =
+    try f(treeWalk) finally treeWalk.release()
 
   def executeIf(condition: => Boolean)(action: => Unit): Boolean =
     if(condition){
       action
       true
-    } else {
-      false
-    }
+    } else false
 
   def optionIf[T](condition: => Boolean)(action: => Option[T]): Option[T] =
-    if(condition){
-      action
-    } else {
-      None
-    }
+    if(condition) action else None
 }

src/main/scala/util/JGitUtil.scala

@@ -159,11 +159,13 @@ object JGitUtil {
    * @return HTML of the file list
    */
   def getFileList(git: Git, revision: String, path: String = "."): List[FileInfo] = {
-    val revWalk = new RevWalk(git.getRepository)
+    val list = new scala.collection.mutable.ListBuffer[(ObjectId, FileMode, String, String)]
+
+    using(new RevWalk(git.getRepository)){ revWalk =>
       val objectId  = git.getRepository.resolve(revision)
       val revCommit = revWalk.parseCommit(objectId)
 
-    val treeWalk = new TreeWalk(git.getRepository)
+      using(new TreeWalk(git.getRepository)){ treeWalk =>
         treeWalk.addTree(revCommit.getTree)
         if(path != "."){
           treeWalk.setRecursive(true)
@@ -189,15 +191,11 @@ object JGitUtil {
             override def clone: TreeFilter = return this
           })
         }
-      
-    val list = new scala.collection.mutable.ListBuffer[(ObjectId, FileMode, String, String)]
-    
         while (treeWalk.next()) {
           list.append((treeWalk.getObjectId(0), treeWalk.getFileMode(0), treeWalk.getPathString, treeWalk.getNameString))
         }
-    
-    treeWalk.release
-    revWalk.dispose
+      }
+    }
 
     val commits = getLatestCommitFromPaths(git, list.toList.map(_._3), revision)
     list.map { case (objectId, fileMode, path, name) =>
@@ -367,7 +365,7 @@ object JGitUtil {
 
       } else {
         // initial commit
-        val treeWalk = new TreeWalk(git.getRepository)
+        using(new TreeWalk(git.getRepository)){ treeWalk =>
           treeWalk.addTree(revCommit.getTree)
           val buffer = new scala.collection.mutable.ListBuffer[DiffInfo]()
           while(treeWalk.next){
@@ -378,11 +376,11 @@ object JGitUtil {
                 JGitUtil.getContent(git, treeWalk.getObjectId(0), false).filter(FileUtil.isText).map(convertFromByteArray))
             }))
           }
-        treeWalk.release
           (buffer.toList, None)
         }
       }
     }
+  }
 
   def getDiffs(git: Git, from: String, to: String, fetchContent: Boolean): List[DiffInfo] = {
     val reader = git.getRepository.newObjectReader