Use Option.map instead of pattern matching.

src/main/scala/app/AccountController.scala

@@ -22,26 +22,19 @@ trait AccountControllerBase extends ControllerBase {
    */
   get("/:userName") {
     val userName = params("userName")
-    getAccountByUserName(userName) match {
+    getAccountByUserName(userName).map {
-      case Some(a) => account.html.userinfo(a, getVisibleRepositories(userName, baseUrl, context.loginAccount.map(_.userName)))
+      account.html.userinfo(_, getVisibleRepositories(userName, baseUrl, context.loginAccount.map(_.userName)))
-      case None => NotFound()
+    } getOrElse NotFound()
-    }
   }
 
   get("/:userName/_edit")(ownerOnly {
     val userName = params("userName")
-    getAccountByUserName(userName) match {
+    getAccountByUserName(userName).map(account.html.useredit(_)) getOrElse NotFound()
-      case Some(a) => account.html.useredit(a)
-      case None => NotFound()
-    }
   })
 
   post("/:userName/_edit", form)(ownerOnly { form =>
     val userName = params("userName")
-    updateAccount(getAccountByUserName(userName).get.copy(
+    updateAccount(getAccountByUserName(userName).get.copy(mailAddress = form.mailAddress, url = form.url))
-      mailAddress    = form.mailAddress,
-      url            = form.url))
-
     redirect("/%s".format(userName))
   })
 

src/main/scala/app/LabelsController.scala

@@ -36,10 +36,8 @@ trait LabelsControllerBase extends ControllerBase {
     val owner      = params("owner")
     val repository = params("repository")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl)
-      case None    => NotFound()
+      .map(issues.html.labeleditlist(getLabels(owner, repository), _)) getOrElse NotFound()
-      case Some(r) => issues.html.labeleditlist(getLabels(owner, repository), r)
-    }
   })
 
   get("/:owner/:repository/issues/label/:labelId/edit")(writableRepository {
@@ -47,13 +45,9 @@ trait LabelsControllerBase extends ControllerBase {
     val repository = params("repository")
     val labelId    = params("labelId").toInt
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      case None    => NotFound()
+      getLabel(owner, repository, labelId).map(label => issues.html.labeledit(Some(label), repositoryInfo)) getOrElse NotFound()
-      case Some(r) => getLabel(owner, repository, labelId) match {
+    } getOrElse NotFound()
-        case None    => NotFound()
-        case Some(l) => issues.html.labeledit(Some(l), r)
-      }
-    }
   })
 
   post("/:owner/:repository/issues/label/:labelId/edit", editForm)(writableRepository { form =>
@@ -61,13 +55,10 @@ trait LabelsControllerBase extends ControllerBase {
     val repository = params("repository")
     val labelId    = params("labelId").toInt
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map{ repositoryInfo =>
-      case None    => NotFound()
+      updateLabel(owner, repository, labelId, form.labelName, form.color.substring(1))
-      case Some(r) => {
+      issues.html.labeleditlist(getLabels(owner, repository), repositoryInfo)
-        updateLabel(owner, repository, labelId, form.labelName, form.color.substring(1))
+    } getOrElse NotFound()
-        issues.html.labeleditlist(getLabels(owner, repository), r)
-      }
-    }
   })
 
   get("/:owner/:repository/issues/label/:labelId/delete")(writableRepository {
@@ -75,13 +66,10 @@ trait LabelsControllerBase extends ControllerBase {
     val repository = params("repository")
     val labelId    = params("labelId").toInt
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      case None    => NotFound()
+      deleteLabel(owner, repository, labelId)
-      case Some(r) => {
+      issues.html.labeleditlist(getLabels(owner, repository), repositoryInfo)
-        deleteLabel(owner, repository, labelId)
+    } getOrElse NotFound()
-        issues.html.labeleditlist(getLabels(owner, repository), r)
-      }
-    }
   })
 
 }

src/main/scala/app/MilestonesController.scala

@@ -26,21 +26,20 @@ trait MilestonesControllerBase extends ControllerBase {
     val repository = params("repository")
     val state      = params.getOrElse("state", "open")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      case None    => NotFound()
+      issues.html.milestones(state,
-      case Some(r) => issues.html.milestones(state, getMilestones(owner, repository),
+        getMilestones(owner, repository),
-        getMilestoneIssueCounts(owner, repository), r, isWritable(owner, repository, context.loginAccount))
+        getMilestoneIssueCounts(owner, repository),
-    }
+        repositoryInfo,
+        isWritable(owner, repository, context.loginAccount))
+    } getOrElse NotFound()
   })
 
   get("/:owner/:repository/issues/milestones/new")(writableRepository {
     val owner      = params("owner")
     val repository = params("repository")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map(issues.html.milestoneedit(None, _)) getOrElse NotFound()
-      case None    => NotFound()
-      case Some(r) => issues.html.milestoneedit(None, r)
-    }
   })
 
   post("/:owner/:repository/issues/milestones/new", milestoneForm)(writableRepository { form =>
@@ -48,7 +47,6 @@ trait MilestonesControllerBase extends ControllerBase {
     val repository = params("repository")
 
     createMilestone(owner, repository, form.title, form.description, form.dueDate)
-
     redirect("/%s/%s/issues/milestones".format(owner, repository))
   })
 
@@ -57,10 +55,8 @@ trait MilestonesControllerBase extends ControllerBase {
     val repository  = params("repository")
     val milestoneId = params("milestoneId").toInt
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map(
-      case None    => NotFound()
+      issues.html.milestoneedit(getMilestone(owner, repository, milestoneId), _)) getOrElse NotFound()
-      case Some(r) => issues.html.milestoneedit(getMilestone(owner, repository, milestoneId), r)
-    }
   })
 
   post("/:owner/:repository/issues/milestones/:milestoneId/edit", milestoneForm)(writableRepository { form =>
@@ -68,13 +64,10 @@ trait MilestonesControllerBase extends ControllerBase {
     val repository  = params("repository")
     val milestoneId = params("milestoneId").toInt
 
-    getMilestone(owner, repository, milestoneId) match {
+    getMilestone(owner, repository, milestoneId).map { milestone =>
-      case None    => NotFound()
+      updateMilestone(milestone.copy(title = form.title, description = form.description, dueDate = form.dueDate))
-      case Some(m) => {
+      redirect("/%s/%s/issues/milestones".format(owner, repository))
-        updateMilestone(m.copy(title = form.title, description = form.description, dueDate = form.dueDate))
+    } getOrElse NotFound()
-        redirect("/%s/%s/issues/milestones".format(owner, repository))
-      }
-    }
   })
 
   get("/:owner/:repository/issues/milestones/:milestoneId/close")(writableRepository {
@@ -82,13 +75,10 @@ trait MilestonesControllerBase extends ControllerBase {
     val repository  = params("repository")
     val milestoneId = params("milestoneId").toInt
 
-    getMilestone(owner, repository, milestoneId) match {
+    getMilestone(owner, repository, milestoneId).map { milestone =>
-      case None    => NotFound()
+      closeMilestone(milestone)
-      case Some(m) => {
+      redirect("/%s/%s/issues/milestones".format(owner, repository))
-        closeMilestone(m)
+    } getOrElse NotFound()
-        redirect("/%s/%s/issues/milestones".format(owner, repository))
-      }
-    }
   })
 
   get("/:owner/:repository/issues/milestones/:milestoneId/open")(writableRepository {
@@ -96,13 +86,10 @@ trait MilestonesControllerBase extends ControllerBase {
     val repository  = params("repository")
     val milestoneId = params("milestoneId").toInt
 
-    getMilestone(owner, repository, milestoneId) match {
+    getMilestone(owner, repository, milestoneId).map { milestone =>
-      case None    => NotFound()
+      openMilestone(milestone)
-      case Some(m) => {
+      redirect("/%s/%s/issues/milestones".format(owner, repository))
-        openMilestone(m)
+    } getOrElse NotFound()
-        redirect("/%s/%s/issues/milestones".format(owner, repository))
-      }
-    }
   })
 
   get("/:owner/:repository/issues/milestones/:milestoneId/delete")(writableRepository {
@@ -110,13 +97,10 @@ trait MilestonesControllerBase extends ControllerBase {
     val repository  = params("repository")
     val milestoneId = params("milestoneId").toInt
 
-    getMilestone(owner, repository, milestoneId) match {
+    getMilestone(owner, repository, milestoneId).map { _ =>
-      case None    => NotFound()
+      deleteMilestone(owner, repository, milestoneId)
-      case Some(m) => {
+      redirect("/%s/%s/issues/milestones".format(owner, repository))
-        deleteMilestone(owner, repository, milestoneId)
+    } getOrElse NotFound()
-        redirect("/%s/%s/issues/milestones".format(owner, repository))
-      }
-    }
   })
 
 }

src/main/scala/app/RepositoryViewerController.scala

@@ -74,15 +74,16 @@ trait RepositoryViewerControllerBase extends ControllerBase {
     val repository = params("repository")
     val branchName = params("branch")
     val page       = params.getOrElse("page", "1").toInt
-    
+
-    JGitUtil.withGit(getRepositoryDir(owner, repository)){ git =>
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      val (logs, hasNext) = JGitUtil.getCommitLog(git, branchName, page, 30)
+      JGitUtil.withGit(getRepositoryDir(owner, repository)){ git =>
-    
+        val (logs, hasNext) = JGitUtil.getCommitLog(git, branchName, page, 30)
-      repo.html.commits(Nil, branchName, getRepository(owner, repository, baseUrl).get,
+
-        logs.splitWith{ (commit1, commit2) =>
+        repo.html.commits(Nil, branchName, repositoryInfo, logs.splitWith{ (commit1, commit2) =>
           view.helpers.date(commit1.time) == view.helpers.date(commit2.time)
         }, page, hasNext)
-    }
+      }
+    } getOrElse NotFound()
   })
   
   /**
@@ -114,50 +115,51 @@ trait RepositoryViewerControllerBase extends ControllerBase {
     val id         = params("id") // branch name or commit id
     val raw        = params.get("raw").getOrElse("false").toBoolean
     val path       = multiParams("splat").head //.replaceFirst("^tree/.+?/", "")
-    val repositoryInfo = getRepository(owner, repository, baseUrl).get
 
-    JGitUtil.withGit(getRepositoryDir(owner, repository)){ git =>
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))
+      JGitUtil.withGit(getRepositoryDir(owner, repository)){ git =>
-      
+        val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))
-      @scala.annotation.tailrec
-      def getPathObjectId(path: String, walk: TreeWalk): ObjectId = walk.next match {
-        case true if(walk.getPathString == path) => walk.getObjectId(0)
-        case true => getPathObjectId(path, walk)
-      }
-      
-      val treeWalk = new TreeWalk(git.getRepository)
-      val objectId = try {
-        treeWalk.addTree(revCommit.getTree)
-        treeWalk.setRecursive(true)
-        getPathObjectId(path, treeWalk)
-      } finally {
-        treeWalk.release
-      }
-      
-      if(raw){
-        // Download
-        contentType = "application/octet-stream"
-        JGitUtil.getContent(git, objectId, false).get
-      } else {
-        // Viewer
-        val large  = FileTypeUtil.isLarge(git.getRepository.getObjectDatabase.open(objectId).getSize)
-        val viewer = if(FileTypeUtil.isImage(path)) "image" else if(large) "large" else "other"
-        val bytes  = if(viewer == "other") JGitUtil.getContent(git, objectId, false) else None
 
-        val content = if(viewer == "other"){
+        @scala.annotation.tailrec
-          if(bytes.isDefined && FileTypeUtil.isText(bytes.get)){
+        def getPathObjectId(path: String, walk: TreeWalk): ObjectId = walk.next match {
-            // text
+          case true if(walk.getPathString == path) => walk.getObjectId(0)
-            JGitUtil.ContentInfo("text", bytes.map(new String(_, "UTF-8")))
+          case true => getPathObjectId(path, walk)
-          } else {
+        }
-            // binary
+
-            JGitUtil.ContentInfo("binary", None)
+        val treeWalk = new TreeWalk(git.getRepository)
-          }
+        val objectId = try {
-        } else {
+          treeWalk.addTree(revCommit.getTree)
-          // image or large
+          treeWalk.setRecursive(true)
-          JGitUtil.ContentInfo(viewer, None)
+          getPathObjectId(path, treeWalk)
+        } finally {
+          treeWalk.release
+        }
+
+        if(raw){
+          // Download
+          contentType = "application/octet-stream"
+          JGitUtil.getContent(git, objectId, false).get
+        } else {
+          // Viewer
+          val large  = FileTypeUtil.isLarge(git.getRepository.getObjectDatabase.open(objectId).getSize)
+          val viewer = if(FileTypeUtil.isImage(path)) "image" else if(large) "large" else "other"
+          val bytes  = if(viewer == "other") JGitUtil.getContent(git, objectId, false) else None
+
+          val content = if(viewer == "other"){
+            if(bytes.isDefined && FileTypeUtil.isText(bytes.get)){
+              // text
+              JGitUtil.ContentInfo("text", bytes.map(new String(_, "UTF-8")))
+            } else {
+              // binary
+              JGitUtil.ContentInfo("binary", None)
+            }
+          } else {
+            // image or large
+            JGitUtil.ContentInfo(viewer, None)
+          }
+
+          repo.html.blob(id, repositoryInfo, path.split("/").toList, content, new JGitUtil.CommitInfo(revCommit))
         }
-        
-        repo.html.blob(id, repositoryInfo, path.split("/").toList, content, new JGitUtil.CommitInfo(revCommit))
       }
     }
   })
@@ -169,14 +171,15 @@ trait RepositoryViewerControllerBase extends ControllerBase {
     val owner      = params("owner")
     val repository = params("repository")
     val id         = params("id")
-    
+
-    JGitUtil.withGit(getRepositoryDir(owner, repository)){ git =>
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))
+      JGitUtil.withGit(getRepositoryDir(owner, repository)){ git =>
-      
+        val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))
-      repo.html.commit(id, new JGitUtil.CommitInfo(revCommit),
+
-        JGitUtil.getBranchesOfCommit(git, revCommit.getName),
+        repo.html.commit(id, new JGitUtil.CommitInfo(revCommit),
-        JGitUtil.getTagsOfCommit(git, revCommit.getName),
+          JGitUtil.getBranchesOfCommit(git, revCommit.getName), JGitUtil.getTagsOfCommit(git, revCommit.getName),
-        getRepository(owner, repository, baseUrl).get, JGitUtil.getDiffs(git, id))
+          repositoryInfo, JGitUtil.getDiffs(git, id))
+      }
     }
   })
   
@@ -241,41 +244,38 @@ trait RepositoryViewerControllerBase extends ControllerBase {
    * @return HTML of the file list
    */
   private def fileList(owner: String, repository: String, revstr: String = "", path: String = ".") = {
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      case None => NotFound()
+      val revision = if(revstr.isEmpty){
-      case Some(repositoryInfo) => {
+        repositoryInfo.repository.defaultBranch
-        val revision = if(revstr.isEmpty){
+      } else {
-          repositoryInfo.repository.defaultBranch
+        revstr
-        } else {
+      }
-          revstr
+
+      JGitUtil.withGit(getRepositoryDir(owner, repository)){ git =>
+      // get latest commit
+        val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(revision))
+
+        val files = JGitUtil.getFileList(git, revision, path)
+
+        // process README.md
+        val readme = files.find(_.name == "README.md").map { file =>
+          new String(JGitUtil.getContent(Git.open(getRepositoryDir(owner, repository)), file.id, true).get, "UTF-8")
         }
 
-        JGitUtil.withGit(getRepositoryDir(owner, repository)){ git =>
+        repo.html.files(
-        // get latest commit
+          // current branch
-          val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(revision))
+          revision,
-
+          // repository
-          val files = JGitUtil.getFileList(git, revision, path)
+          repositoryInfo,
-
+          // current path
-          // process README.md
+          if(path == ".") Nil else path.split("/").toList,
-          val readme = files.find(_.name == "README.md").map { file =>
+          // latest commit
-            new String(JGitUtil.getContent(Git.open(getRepositoryDir(owner, repository)), file.id, true).get, "UTF-8")
+          new JGitUtil.CommitInfo(revCommit),
-          }
+          // file list
-
+          files,
-          repo.html.files(
+          // readme
-            // current branch
+          readme
-            revision,
+        )
-            // repository
-            repositoryInfo,
-            // current path
-            if(path == ".") Nil else path.split("/").toList,
-            // latest commit
-            new JGitUtil.CommitInfo(revCommit),
-            // file list
-            files,
-            // readme
-            readme
-          )
-        }
       }
     }
   }

src/main/scala/app/SettingsController.scala

@@ -43,10 +43,7 @@ trait SettingsControllerBase extends ControllerBase {
     val owner      = params("owner")
     val repository = params("repository")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map(settings.html.options(_)) getOrElse NotFound()
-      case Some(r) => settings.html.options(r)
-      case None    => NotFound()
-    }
   })
   
   /**
@@ -69,10 +66,8 @@ trait SettingsControllerBase extends ControllerBase {
     val owner      = params("owner")
     val repository = params("repository")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map(
-      case Some(r) => settings.html.collaborators(getCollaborators(owner, repository), r)
+      settings.html.collaborators(getCollaborators(owner, repository), _)) getOrElse NotFound()
-      case None    => NotFound()
-    }
   })
 
   /**
@@ -105,10 +100,7 @@ trait SettingsControllerBase extends ControllerBase {
     val owner      = params("owner")
     val repository = params("repository")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map(settings.html.delete(_)) getOrElse NotFound()
-      case Some(r) => settings.html.delete(r)
-      case None    => NotFound()
-    }
   })
 
   /**

src/main/scala/app/WikiController.scala

@@ -31,24 +31,23 @@ trait WikiControllerBase extends ControllerBase {
     val owner      = params("owner")
     val repository = params("repository")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      case Some(repoInfo) => getWikiPage(owner, repository, "Home") match {
+      getWikiPage(owner, repository, "Home").map { page =>
-        case Some(page) => wiki.html.wiki("Home", page, repoInfo, isWritable(owner, repository, context.loginAccount))
+        wiki.html.wiki("Home", page, repositoryInfo, isWritable(owner, repository, context.loginAccount))
-        case None => redirect("/%s/%s/wiki/Home/_edit".format(owner, repository))
+      } getOrElse redirect("/%s/%s/wiki/Home/_edit".format(owner, repository))
-      }
+    } getOrElse NotFound()
-      case None => NotFound()
-    }
   })
   
   get("/:owner/:repository/wiki/:page")(readableRepository {
     val owner      = params("owner")
     val repository = params("repository")
     val pageName   = params("page")
-    
+
-    getWikiPage(owner, repository, pageName) match {
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      case Some(page) => wiki.html.wiki(pageName, page, getRepository(owner, repository, baseUrl).get, isWritable(owner, repository, context.loginAccount))
+      getWikiPage(owner, repository, pageName).map { page =>
-      case None => redirect("/%s/%s/wiki/%s/_edit".format(owner, repository, pageName)) // TODO URLEncode
+        wiki.html.wiki(pageName, page, repositoryInfo, isWritable(owner, repository, context.loginAccount))
-    }
+      } getOrElse redirect("/%s/%s/wiki/%s/_edit".format(owner, repository, pageName)) // TODO URLEncode
+    } getOrElse NotFound()
   })
   
   get("/:owner/:repository/wiki/:page/_history")(readableRepository {
@@ -56,12 +55,11 @@ trait WikiControllerBase extends ControllerBase {
     val repository = params("repository")
     val page       = params("page")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      case Some(repoInfo) => JGitUtil.withGit(getWikiRepositoryDir(owner, repository)){ git =>
+      JGitUtil.withGit(getWikiRepositoryDir(owner, repository)){ git =>
-        wiki.html.wikihistory(Some(page), JGitUtil.getCommitLog(git, "master", path = page + ".md")._1, repoInfo)
+        wiki.html.wikihistory(Some(page), JGitUtil.getCommitLog(git, "master", path = page + ".md")._1, repositoryInfo)
       }
-      case None => NotFound()
+    } getOrElse NotFound()
-    }
   })
   
   get("/:owner/:repository/wiki/:page/_compare/:commitId")(readableRepository {
@@ -69,11 +67,12 @@ trait WikiControllerBase extends ControllerBase {
     val repository = params("repository")
     val page       = params("page")
     val commitId   = params("commitId").split("\\.\\.\\.")
-    
+
-    JGitUtil.withGit(getWikiRepositoryDir(owner, repository)){ git =>
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      wiki.html.wikicompare(Some(page),
+      JGitUtil.withGit(getWikiRepositoryDir(owner, repository)){ git =>
-        getWikiDiffs(git, commitId(0), commitId(1)), getRepository(owner, repository, baseUrl).get)
+        wiki.html.wikicompare(Some(page), getWikiDiffs(git, commitId(0), commitId(1)), repositoryInfo)
-    }
+      }
+    } getOrElse NotFound()
   })
   
   get("/:owner/:repository/wiki/_compare/:commitId")(readableRepository {
@@ -81,12 +80,11 @@ trait WikiControllerBase extends ControllerBase {
     val repository = params("repository")
     val commitId   = params("commitId").split("\\.\\.\\.")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      case Some(repoInfo) => JGitUtil.withGit(getWikiRepositoryDir(owner, repository)){ git =>
+      JGitUtil.withGit(getWikiRepositoryDir(owner, repository)){ git =>
-        wiki.html.wikicompare(None, getWikiDiffs(git, commitId(0), commitId(1)), repoInfo)
+        wiki.html.wikicompare(None, getWikiDiffs(git, commitId(0), commitId(1)), repositoryInfo)
       }
-      case None => NotFound()
+    } getOrElse NotFound()
-    }
   })
   
   get("/:owner/:repository/wiki/:page/_edit")(writableRepository {
@@ -94,10 +92,8 @@ trait WikiControllerBase extends ControllerBase {
     val repository = params("repository")
     val page       = params("page")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map(
-      case Some(repoInfo) => wiki.html.wikiedit(page, getWikiPage(owner, repository, page), repoInfo)
+      wiki.html.wikiedit(page, getWikiPage(owner, repository, page), _)) getOrElse NotFound()
-      case None => NotFound()
-    }
   })
   
   post("/:owner/:repository/wiki/_edit", editForm)(writableRepository { form =>
@@ -115,10 +111,7 @@ trait WikiControllerBase extends ControllerBase {
     val owner      = params("owner")
     val repository = params("repository")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map(wiki.html.wikiedit("", None, _)) getOrElse NotFound()
-      case Some(repoInfo) => wiki.html.wikiedit("", None, repoInfo)
-      case None => NotFound()
-    }
   })
   
   post("/:owner/:repository/wiki/_new", newForm)(writableRepository { form =>
@@ -146,22 +139,20 @@ trait WikiControllerBase extends ControllerBase {
     val owner      = params("owner")
     val repository = params("repository")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map {
-      case Some(repoInfo) => wiki.html.wikipages(getWikiPageList(owner, repository), repoInfo, isWritable(owner, repository, context.loginAccount))
+      wiki.html.wikipages(getWikiPageList(owner, repository), _, isWritable(owner, repository, context.loginAccount))
-      case None => NotFound()
+    } getOrElse NotFound()
-    }
   })
   
   get("/:owner/:repository/wiki/_history")(readableRepository {
     val owner      = params("owner")
     val repository = params("repository")
 
-    getRepository(owner, repository, baseUrl) match {
+    getRepository(owner, repository, baseUrl).map { repositoryInfo =>
-      case Some(repoInfo) => JGitUtil.withGit(getWikiRepositoryDir(owner, repository)){ git =>
+      JGitUtil.withGit(getWikiRepositoryDir(owner, repository)){ git =>
-        wiki.html.wikihistory(None, JGitUtil.getCommitLog(git, "master")._1, repoInfo)
+        wiki.html.wikihistory(None, JGitUtil.getCommitLog(git, "master")._1, repositoryInfo)
       }
-      case None => NotFound()
+    } getOrElse NotFound()
-    }
   })
 
   get("/:owner/:repository/wiki/_blob/*")(readableRepository {
@@ -169,13 +160,10 @@ trait WikiControllerBase extends ControllerBase {
     val repository = params("repository")
     val path       = multiParams("splat").head
 
-    getFileContent(owner, repository, path) match {
+    getFileContent(owner, repository, path).map { content =>
-      case Some(content) => {
         contentType = "application/octet-stream"
         content
-      }
+    } getOrElse NotFound()
-      case None => NotFound()
-    }
   })
 
   private def unique: Constraint = new Constraint(){