Use ControlUtil.

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,45 +159,43 @@ 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 objectId = git.getRepository.resolve(revision)
-    val revCommit = revWalk.parseCommit(objectId)
-      
-    val treeWalk = new TreeWalk(git.getRepository)
-    treeWalk.addTree(revCommit.getTree)
-    if(path != "."){
-      treeWalk.setRecursive(true)
-      treeWalk.setFilter(new TreeFilter(){
-
-        var stopRecursive = false
-
-        def include(walker: TreeWalk): Boolean = {
-          val targetPath = walker.getPathString
-          if((path + "/").startsWith(targetPath)){
-            true
-          } else if(targetPath.startsWith(path + "/") && targetPath.substring(path.length + 1).indexOf("/") < 0){
-            stopRecursive = true
-            treeWalk.setRecursive(false)
-            true
-          } else {
-            false
-          }
-        }
-
-        def shouldBeRecursive(): Boolean = !stopRecursive
-
-        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))
+
+    using(new RevWalk(git.getRepository)){ revWalk =>
+      val objectId  = git.getRepository.resolve(revision)
+      val revCommit = revWalk.parseCommit(objectId)
+
+      using(new TreeWalk(git.getRepository)){ treeWalk =>
+        treeWalk.addTree(revCommit.getTree)
+        if(path != "."){
+          treeWalk.setRecursive(true)
+          treeWalk.setFilter(new TreeFilter(){
+
+            var stopRecursive = false
+
+            def include(walker: TreeWalk): Boolean = {
+              val targetPath = walker.getPathString
+              if((path + "/").startsWith(targetPath)){
+                true
+              } else if(targetPath.startsWith(path + "/") && targetPath.substring(path.length + 1).indexOf("/") < 0){
+                stopRecursive = true
+                treeWalk.setRecursive(false)
+                true
+              } else {
+                false
+              }
+            }
+
+            def shouldBeRecursive(): Boolean = !stopRecursive
+
+            override def clone: TreeFilter = return this
+          })
+        }
+        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,19 +365,19 @@ object JGitUtil {
 
       } else {
         // initial commit
-        val treeWalk = new TreeWalk(git.getRepository)
-        treeWalk.addTree(revCommit.getTree)
-        val buffer = new scala.collection.mutable.ListBuffer[DiffInfo]()
-        while(treeWalk.next){
-          buffer.append((if(!fetchContent){
-            DiffInfo(ChangeType.ADD, null, treeWalk.getPathString, None, None)
-          } else {
-            DiffInfo(ChangeType.ADD, null, treeWalk.getPathString, None,
-              JGitUtil.getContent(git, treeWalk.getObjectId(0), false).filter(FileUtil.isText).map(convertFromByteArray))
-          }))
+        using(new TreeWalk(git.getRepository)){ treeWalk =>
+          treeWalk.addTree(revCommit.getTree)
+          val buffer = new scala.collection.mutable.ListBuffer[DiffInfo]()
+          while(treeWalk.next){
+            buffer.append((if(!fetchContent){
+              DiffInfo(ChangeType.ADD, null, treeWalk.getPathString, None, None)
+            } else {
+              DiffInfo(ChangeType.ADD, null, treeWalk.getPathString, None,
+                JGitUtil.getContent(git, treeWalk.getObjectId(0), false).filter(FileUtil.isText).map(convertFromByteArray))
+            }))
+          }
+          (buffer.toList, None)
         }
-        treeWalk.release
-        (buffer.toList, None)
       }
     }
   }