Use ControlUtil.

2025-11-09 15:05:50 +01:00 · 2013-09-22 01:24:04 +09:00
parent c00b704843
commit f30c9f6171
5 changed files with 124 additions and 150 deletions
--- a/src/main/scala/app/PullRequestsController.scala
+++ b/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,31 +370,30 @@ trait PullRequestsControllerBase extends ControllerBase {
    }
  }

-  private def searchPullRequests(userName: Option[String], repository: RepositoryService.RepositoryInfo) = {
-    val owner      = repository.owner
-    val repoName   = repository.name
-    val filterUser = userName.map { x => Map("created_by" -> x) } getOrElse Map("all" -> "")
-    val page = IssueSearchCondition.page(request)
-    val sessionKey = s"${owner}/${repoName}/pulls"
+  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"

-    // retrieve search condition
-    val condition = if(request.getQueryString == null){
-      session.get(sessionKey).getOrElse(IssueSearchCondition()).asInstanceOf[IssueSearchCondition]
-    } else IssueSearchCondition(request)
+      // retrieve search condition
+      val condition = if(request.getQueryString == null){
+        session.get(sessionKey).getOrElse(IssueSearchCondition()).asInstanceOf[IssueSearchCondition]
+      } else IssueSearchCondition(request)

-    session.put(sessionKey, condition)
+      session.put(sessionKey, condition)

-    pulls.html.list(
-      searchIssue(condition, filterUser, true, (page - 1) * PullRequestLimit, PullRequestLimit, owner -> repoName),
-      getPullRequestCountGroupByUser(condition.state == "closed", owner, Some(repoName)),
-      userName,
-      page,
-      countIssue(condition.copy(state = "open"), filterUser, true, owner -> repoName),
-      countIssue(condition.copy(state = "closed"), filterUser, true, owner -> repoName),
-      countIssue(condition, Map.empty, true, owner -> repoName),
-      condition,
-      repository,
-      hasWritePermission(owner, repoName, context.loginAccount))
-  }
+      pulls.html.list(
+        searchIssue(condition, filterUser, true, (page - 1) * PullRequestLimit, PullRequestLimit, owner -> repoName),
+        getPullRequestCountGroupByUser(condition.state == "closed", owner, Some(repoName)),
+        userName,
+        page,
+        countIssue(condition.copy(state = "open"), filterUser, true, owner -> repoName),
+        countIssue(condition.copy(state = "closed"), filterUser, true, owner -> repoName),
+        countIssue(condition, Map.empty, true, owner -> repoName),
+        condition,
+        repository,
+        hasWritePermission(owner, repoName, context.loginAccount))
+    }

 }
--- a/src/main/scala/app/RepositorySettingsController.scala
+++ b/src/main/scala/app/RepositorySettingsController.scala
@@ -180,25 +180,25 @@ 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("/")
-      getWebHookURLs(paths(1), paths(2)).map(_.url).find(_ == value).map(_ => "URL had been registered already.")
-    }
+    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.")
+      }
  }

  /**
   * 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("/")
-      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))
-                  => Some("User can access this repository already.")
-        case _    => None
+    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))
+                    => Some("User can access this repository already.")
+          case _    => None
+        }
      }
-    }
  }

 }
--- a/src/main/scala/app/RepositoryViewerController.scala
+++ b/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,13 +126,13 @@ 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))
-
-      JGitUtil.getDiffs(git, id) match { case (diffs, oldCommitId) =>
-        repo.html.commit(id, new JGitUtil.CommitInfo(revCommit),
-          JGitUtil.getBranchesOfCommit(git, revCommit.getName),
-          JGitUtil.getTagsOfCommit(git, revCommit.getName),
-          repository, diffs, oldCommitId)
+      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),
+            JGitUtil.getTagsOfCommit(git, revCommit.getName),
+            repository, diffs, oldCommitId)
+        }
      }
    }
  })
@@ -238,19 +235,19 @@ 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
-          val readme = files.find(_.name == "README.md").map { file =>
-            StringUtil.convertFromByteArray(JGitUtil.getContent(Git.open(getRepositoryDir(repository.owner, repository.name)), file.id, true).get)
-          }
+            val files = JGitUtil.getFileList(git, revision, path)
+            // process README.md
+            val readme = files.find(_.name == "README.md").map { file =>
+              StringUtil.convertFromByteArray(JGitUtil.getContent(Git.open(getRepositoryDir(repository.owner, repository.name)), file.id, true).get)
+            }

-          repo.html.files(revision, repository,
-            if(path == ".") Nil else path.split("/").toList, // current path
-            new JGitUtil.CommitInfo(revCommit), // latest commit
-            files, readme)
+            repo.html.files(revision, repository,
+              if(path == ".") Nil else path.split("/").toList, // current path
+              new JGitUtil.CommitInfo(revCommit), // latest commit
+              files, readme)
+          }
        } getOrElse NotFound
      }
    }