Merge branch 'master' into toggle_gravatar

Conflicts: src/main/scala/view/AvatarImageProvider.scala
2025-11-08 06:25:51 +01:00 · 2013-08-06 01:58:47 +09:00
parent b61836adf7 cfb2f5beb9
commit b31b7e1e86
59 changed files with 2956 additions and 748 deletions
--- a/src/main/scala/app/AccountController.scala
+++ b/src/main/scala/app/AccountController.scala
@@ -58,7 +58,7 @@ trait AccountControllerBase extends AccountManagementControllerBase with FlashMa
        case _ =>
          _root_.account.html.repositories(account,
            if(account.isGroupAccount) Nil else getGroupsByUserName(userName),
-            getVisibleRepositories(userName, baseUrl, context.loginAccount.map(_.userName)))
+            getVisibleRepositories(context.loginAccount, baseUrl, Some(userName)))
      }
    } getOrElse NotFound
  }
--- a/src/main/scala/app/ControllerBase.scala
+++ b/src/main/scala/app/ControllerBase.scala
@@ -1,7 +1,7 @@
 package app

 import _root_.util.Directory._
-import _root_.util.{FileUtil, Validations}
+import _root_.util.{StringUtil, FileUtil, Validations}
 import org.scalatra._
 import org.scalatra.json._
 import org.json4s._
@@ -10,7 +10,7 @@ import org.apache.commons.io.FileUtils
 import model.Account
 import scala.Some
 import service.AccountService
-import javax.servlet.http.{HttpSession, HttpServletRequest}
+import javax.servlet.http.{HttpServletResponse, HttpSession, HttpServletRequest}
 import java.text.SimpleDateFormat
 import javax.servlet.{FilterChain, ServletResponse, ServletRequest}

@@ -23,16 +23,28 @@ abstract class ControllerBase extends ScalatraFilter
  implicit val jsonFormats = DefaultFormats

  override def doFilter(request: ServletRequest, response: ServletResponse, chain: FilterChain) {
-    val httpRequest = request.asInstanceOf[HttpServletRequest]
-    val path = httpRequest.getRequestURI.substring(request.getServletContext.getContextPath.length)
+    val httpRequest  = request.asInstanceOf[HttpServletRequest]
+    val httpResponse = response.asInstanceOf[HttpServletResponse]
+    val context      = request.getServletContext.getContextPath
+    val path         = httpRequest.getRequestURI.substring(context.length)

    if(path.startsWith("/console/")){
-      Option(httpRequest.getSession.getAttribute("LOGIN_ACCOUNT").asInstanceOf[Account]).collect {
-        case account if(account.isAdmin) => chain.doFilter(request, response)
+      val account = httpRequest.getSession.getAttribute("LOGIN_ACCOUNT").asInstanceOf[Account]
+      if(account == null){
+        // Redirect to login form
+        httpResponse.sendRedirect(context + "/signin?" + path)
+      } else if(account.isAdmin){
+        // H2 Console (administrators only)
+        chain.doFilter(request, response)
+      } else {
+        // Redirect to dashboard
+        httpResponse.sendRedirect(context + "/")
      }
    } else if(path.startsWith("/git/")){
+      // Git repository
      chain.doFilter(request, response)
    } else {
+      // Scalatra actions
      super.doFilter(request, response, chain)
    }
  }
--- a/src/main/scala/app/CreateRepositoryController.scala
+++ b/src/main/scala/app/CreateRepositoryController.scala
@@ -1,27 +1,30 @@
 package app

 import util.Directory._
-import util.{JGitUtil, UsersAuthenticator}
+import util.{LockUtil, JGitUtil, UsersAuthenticator, ReferrerAuthenticator}
 import service._
 import java.io.File
 import org.eclipse.jgit.api.Git
 import org.apache.commons.io._
 import jp.sf.amateras.scalatra.forms._
+import org.eclipse.jgit.lib.PersonIdent

 class CreateRepositoryController extends CreateRepositoryControllerBase
  with RepositoryService with AccountService with WikiService with LabelsService with ActivityService
-  with UsersAuthenticator
+  with UsersAuthenticator with ReferrerAuthenticator

 /**
 * Creates new repository.
 */
 trait CreateRepositoryControllerBase extends ControllerBase {
  self: RepositoryService with AccountService with WikiService with LabelsService with ActivityService
-    with UsersAuthenticator =>
+    with UsersAuthenticator with ReferrerAuthenticator =>

  case class RepositoryCreationForm(owner: String, name: String, description: Option[String], isPrivate: Boolean, createReadme: Boolean)

-  val form = mapping(
+  case class ForkRepositoryForm(owner: String, name: String)
+
+  val newForm = mapping(
    "owner"        -> trim(label("Owner"          , text(required, maxlength(40), identifier, existsAccount))),
    "name"         -> trim(label("Repository name", text(required, maxlength(40), identifier, unique))),
    "description"  -> trim(label("Description"    , optional(text()))),
@@ -29,6 +32,11 @@ trait CreateRepositoryControllerBase extends ControllerBase {
    "createReadme" -> trim(label("Create README"  , boolean()))
  )(RepositoryCreationForm.apply)

+  val forkForm = mapping(
+    "owner" -> trim(label("Repository owner", text(required))),
+    "name"  -> trim(label("Repository name",  text(required)))
+  )(ForkRepositoryForm.apply)
+
  /**
   * Show the new repository form.
   */
@@ -39,77 +47,142 @@ trait CreateRepositoryControllerBase extends ControllerBase {
  /**
   * Create new repository.
   */
-  post("/new", form)(usersOnly { form =>
-    val ownerAccount  = getAccountByUserName(form.owner).get
-    val loginAccount  = context.loginAccount.get
-    val loginUserName = loginAccount.userName
+  post("/new", newForm)(usersOnly { form =>
+    LockUtil.lock(s"${form.owner}/${form.name}/create"){
+      if(getRepository(form.owner, form.name, baseUrl).isEmpty){
+        val ownerAccount  = getAccountByUserName(form.owner).get
+        val loginAccount  = context.loginAccount.get
+        val loginUserName = loginAccount.userName

-    // Insert to the database at first
-    createRepository(form.name, form.owner, form.description, form.isPrivate)
+        // Insert to the database at first
+        createRepository(form.name, form.owner, form.description, form.isPrivate)

-    // Add collaborators for group repository
-    if(ownerAccount.isGroupAccount){
-      getGroupMembers(form.owner).foreach { userName =>
-        addCollaborator(form.owner, form.name, userName)
+        // Add collaborators for group repository
+        if(ownerAccount.isGroupAccount){
+          getGroupMembers(form.owner).foreach { userName =>
+            addCollaborator(form.owner, form.name, userName)
+          }
+        }
+
+        // Insert default labels
+        insertDefaultLabels(loginUserName, form.name)
+
+        // Create the actual repository
+        val gitdir = getRepositoryDir(form.owner, form.name)
+        JGitUtil.initRepository(gitdir)
+
+        if(form.createReadme){
+          val tmpdir = getInitRepositoryDir(form.owner, form.name)
+          try {
+            // Clone the repository
+            Git.cloneRepository.setURI(gitdir.toURI.toString).setDirectory(tmpdir).call
+
+            // Create README.md
+            FileUtils.writeStringToFile(new File(tmpdir, "README.md"),
+              if(form.description.nonEmpty){
+                form.name + "\n" +
+                  "===============\n" +
+                  "\n" +
+                  form.description.get
+              } else {
+                form.name + "\n" +
+                  "===============\n"
+              }, "UTF-8")
+
+            val git = Git.open(tmpdir)
+            git.add.addFilepattern("README.md").call
+            git.commit
+              .setCommitter(new PersonIdent(loginUserName, loginAccount.mailAddress))
+              .setMessage("Initial commit").call
+            git.push.call
+
+          } finally {
+            FileUtils.deleteDirectory(tmpdir)
+          }
+        }
+
+        // Create Wiki repository
+        createWikiRepository(loginAccount, form.owner, form.name)
+
+        // Record activity
+        recordCreateRepositoryActivity(form.owner, form.name, loginUserName)
      }
+
+      // redirect to the repository
+      redirect(s"/${form.owner}/${form.name}")
    }
-
-    // Insert default labels
-    createLabel(form.owner, form.name, "bug", "fc2929")
-    createLabel(form.owner, form.name, "duplicate", "cccccc")
-    createLabel(form.owner, form.name, "enhancement", "84b6eb")
-    createLabel(form.owner, form.name, "invalid", "e6e6e6")
-    createLabel(form.owner, form.name, "question", "cc317c")
-    createLabel(form.owner, form.name, "wontfix", "ffffff")
-
-    // Create the actual repository
-    val gitdir = getRepositoryDir(form.owner, form.name)
-    JGitUtil.initRepository(gitdir)
-
-    if(form.createReadme){
-      val tmpdir = getInitRepositoryDir(form.owner, form.name)
-      try {
-        // Clone the repository
-        Git.cloneRepository.setURI(gitdir.toURI.toString).setDirectory(tmpdir).call
-
-        // Create README.md
-        FileUtils.writeStringToFile(new File(tmpdir, "README.md"),
-          if(form.description.nonEmpty){
-            form.name + "\n" +
-            "===============\n" +
-            "\n" +
-            form.description.get
-          } else {
-            form.name + "\n" +
-            "===============\n"
-          }, "UTF-8")
-
-        val git = Git.open(tmpdir)
-        git.add.addFilepattern("README.md").call
-        git.commit.setMessage("Initial commit").call
-        git.push.call
-
-      } finally {
-        FileUtils.deleteDirectory(tmpdir)
-      }
-    }
-
-    // Create Wiki repository
-    createWikiRepository(loginAccount, form.owner, form.name)
-
-    // Record activity
-    recordCreateRepositoryActivity(form.owner, form.name, loginUserName)
-
-    // redirect to the repository
-    redirect(s"/${form.owner}/${form.name}")
  })

+  post("/:owner/:repository/_fork")(referrersOnly { repository =>
+    val loginAccount   = context.loginAccount.get
+    val loginUserName  = loginAccount.userName
+
+    LockUtil.lock(s"${loginUserName}/${repository.name}/create"){
+      if(getRepository(loginUserName, repository.name, baseUrl).isEmpty){
+        // Insert to the database at first
+        val originUserName = repository.repository.originUserName.getOrElse(repository.owner)
+        val originRepositoryName = repository.repository.originRepositoryName.getOrElse(repository.name)
+
+        createRepository(
+          repositoryName       = repository.name,
+          userName             = loginUserName,
+          description          = repository.repository.description,
+          isPrivate            = repository.repository.isPrivate,
+          originRepositoryName = Some(originRepositoryName),
+          originUserName       = Some(originUserName),
+          parentRepositoryName = Some(repository.name),
+          parentUserName       = Some(repository.owner)
+        )
+
+        // Insert default labels
+        insertDefaultLabels(loginUserName, repository.name)
+
+        // clone repository actually
+        JGitUtil.cloneRepository(
+          getRepositoryDir(repository.owner, repository.name),
+          getRepositoryDir(loginUserName, repository.name))
+
+        // Create Wiki repository
+        JGitUtil.cloneRepository(
+          getWikiRepositoryDir(repository.owner, repository.name),
+          getWikiRepositoryDir(loginUserName, repository.name))
+
+        // insert commit id
+        JGitUtil.withGit(getRepositoryDir(loginUserName, repository.name)){ git =>
+          JGitUtil.getRepositoryInfo(loginUserName, repository.name, baseUrl).branchList.foreach { branch =>
+            JGitUtil.getCommitLog(git, branch) match {
+              case Right((commits, _)) => commits.foreach { commit =>
+                if(!existsCommitId(loginUserName, repository.name, commit.id)){
+                  insertCommitId(loginUserName, repository.name, commit.id)
+                }
+              }
+              case Left(_) => ???
+            }
+          }
+        }
+
+        // Record activity
+        recordForkActivity(repository.owner, repository.name, loginUserName)
+      }
+      // redirect to the repository
+      redirect("/%s/%s".format(loginUserName, repository.name))
+    }
+  })
+
+  private def insertDefaultLabels(userName: String, repositoryName: String): Unit = {
+    createLabel(userName, repositoryName, "bug", "fc2929")
+    createLabel(userName, repositoryName, "duplicate", "cccccc")
+    createLabel(userName, repositoryName, "enhancement", "84b6eb")
+    createLabel(userName, repositoryName, "invalid", "e6e6e6")
+    createLabel(userName, repositoryName, "question", "cc317c")
+    createLabel(userName, repositoryName, "wontfix", "ffffff")
+  }
+
  private def existsAccount: Constraint = new Constraint(){
    def validate(name: String, value: String): Option[String] =
      if(getAccountByUserName(value).isEmpty) Some("User or group does not exist.") else None
  }

-  
  /**
   * Duplicate check for the repository name.
   */
@@ -120,4 +193,4 @@ trait CreateRepositoryControllerBase extends ControllerBase {
      }
  }
  
-}
+}
--- a/src/main/scala/app/DashboardController.scala
+++ b/src/main/scala/app/DashboardController.scala
@@ -33,17 +33,25 @@ trait DashboardControllerBase extends ControllerBase {

    session.put(sessionKey, condition)

-    val repositories = getAccessibleRepositories(context.loginAccount, baseUrl)
+    val userName = context.loginAccount.get.userName
+    val repositories = getUserRepositories(userName, baseUrl).map(repo => repo.owner -> repo.name)
+    val filterUser = Map(filter -> userName)
+    val page = IssueSearchCondition.page(request)
    // 
    dashboard.html.issues(
-        issues.html.listparts(Nil, 0, 0, 0, condition),
-        0,
-        0,
-        0,
-        repositories,
+        issues.html.listparts(
+            searchIssue(condition, filterUser, false, (page - 1) * IssueLimit, IssueLimit, repositories: _*),
+            page,
+            countIssue(condition.copy(state = "open"), filterUser, false, repositories: _*),
+            countIssue(condition.copy(state = "closed"), filterUser, false, repositories: _*),
+            condition),
+        countIssue(condition, Map.empty, false, repositories: _*),
+        countIssue(condition, Map("assigned" -> userName), false, repositories: _*),
+        countIssue(condition, Map("created_by" -> userName), false, repositories: _*),
+        countIssueGroupByRepository(condition, filterUser, repositories: _*),
        condition,
        filter)    
    
  }

-}
+}
--- a/src/main/scala/app/IndexController.scala
+++ b/src/main/scala/app/IndexController.scala
@@ -16,19 +16,22 @@ trait IndexControllerBase extends ControllerBase {
    val loginAccount = context.loginAccount

    html.index(getRecentActivities(),
-      getAccessibleRepositories(loginAccount, baseUrl),
+      getVisibleRepositories(loginAccount, baseUrl),
      loadSystemSettings(),
-      loginAccount.map{ account => getRepositoryNamesOfUser(account.userName) }.getOrElse(Nil)
+      loginAccount.map{ account => getUserRepositories(account.userName, baseUrl) }.getOrElse(Nil)
    )
  }

  /**
   * JSON API for collaborator completion.
+   *
+   * TODO Move to other controller?
   */
-  // TODO Move to other controller?
  get("/_user/proposals")(usersOnly {
    contentType = formats("json")
-    org.json4s.jackson.Serialization.write(Map("options" -> getAllUsers.filter(!_.isGroupAccount).map(_.userName).toArray))
+    org.json4s.jackson.Serialization.write(
+      Map("options" -> getAllUsers.filter(!_.isGroupAccount).map(_.userName).toArray)
+    )
  })


--- a/src/main/scala/app/IssuesController.scala
+++ b/src/main/scala/app/IssuesController.scala
@@ -128,14 +128,22 @@ trait IssuesControllerBase extends ControllerBase {
  })

  post("/:owner/:repository/issue_comments/new", commentForm)(readableUsersOnly { (form, repository) =>
-    handleComment(form.issueId, Some(form.content), repository)() map { id =>
-      redirect(s"/${repository.owner}/${repository.name}/issues/${form.issueId}#comment-${id}")
+    handleComment(form.issueId, Some(form.content), repository)() map { case (issue, id) =>
+      if(issue.isPullRequest){
+        redirect(s"/${repository.owner}/${repository.name}/pull/${form.issueId}#comment-${id}")
+      } else {
+        redirect(s"/${repository.owner}/${repository.name}/issues/${form.issueId}#comment-${id}")
+      }
    } getOrElse NotFound
  })

  post("/:owner/:repository/issue_comments/state", issueStateForm)(readableUsersOnly { (form, repository) =>
-    handleComment(form.issueId, form.content, repository)() map { id =>
-      redirect(s"/${repository.owner}/${repository.name}/issues/${form.issueId}#comment-${id}")
+    handleComment(form.issueId, form.content, repository)() map { case (issue, id) =>
+      if(issue.isPullRequest){
+        redirect(s"/${repository.owner}/${repository.name}/pull/${form.issueId}#comment-${id}")
+      } else {
+        redirect(s"/${repository.owner}/${repository.name}/issues/${form.issueId}#comment-${id}")
+      }
    } getOrElse NotFound
  })

@@ -294,23 +302,17 @@ trait IssuesControllerBase extends ControllerBase {
      content foreach ( recordCommentIssueActivity(owner, name, userName, issueId, _) )
      recordActivity foreach ( _ (owner, name, userName, issueId, issue.title) )

-      commentId
+      (issue, commentId)
    }
  }

  private def searchIssues(filter: String, repository: RepositoryService.RepositoryInfo) = {
    val owner      = repository.owner
    val repoName   = repository.name
-    val userName   = if(filter != "all") Some(params("userName")) else None
+    val filterUser = Map(filter -> params.getOrElse("userName", ""))
+    val page = IssueSearchCondition.page(request)
    val sessionKey = s"${owner}/${repoName}/issues"

-    val page = try {
-      val i = params.getOrElse("page", "1").toInt
-      if(i <= 0) 1 else i
-    } catch {
-      case e: NumberFormatException => 1
-    }
-
    // retrieve search condition
    val condition = if(request.getQueryString == null){
      session.get(sessionKey).getOrElse(IssueSearchCondition()).asInstanceOf[IssueSearchCondition]
@@ -319,17 +321,17 @@ trait IssuesControllerBase extends ControllerBase {
    session.put(sessionKey, condition)

    issues.html.list(
-        searchIssue(owner, repoName, condition, filter, userName, (page - 1) * IssueLimit, IssueLimit),
+        searchIssue(condition, filterUser, false, (page - 1) * IssueLimit, IssueLimit, owner -> repoName),
        page,
        (getCollaborators(owner, repoName) :+ owner).sorted,
        getMilestones(owner, repoName),
        getLabels(owner, repoName),
-        countIssue(owner, repoName, condition.copy(state = "open"), filter, userName),
-        countIssue(owner, repoName, condition.copy(state = "closed"), filter, userName),
-        countIssue(owner, repoName, condition, "all", None),
-        context.loginAccount.map(x => countIssue(owner, repoName, condition, "assigned", Some(x.userName))),
-        context.loginAccount.map(x => countIssue(owner, repoName, condition, "created_by", Some(x.userName))),
-        countIssueGroupByLabels(owner, repoName, condition, filter, userName),
+        countIssue(condition.copy(state = "open"), filterUser, false, owner -> repoName),
+        countIssue(condition.copy(state = "closed"), filterUser, false, owner -> repoName),
+        countIssue(condition, Map.empty, false, owner -> repoName),
+        context.loginAccount.map(x => countIssue(condition, Map("assigned" -> x.userName), false, owner -> repoName)),
+        context.loginAccount.map(x => countIssue(condition, Map("created_by" -> x.userName), false, owner -> repoName)),
+        countIssueGroupByLabels(owner, repoName, condition, filterUser),
        condition,
        filter,
        repository,
--- a/src/main/scala/app/PullRequestsController.scala
+++ b/src/main/scala/app/PullRequestsController.scala
@@ -0,0 +1,400 @@
+package app
+
+import util.{LockUtil, CollaboratorsAuthenticator, JGitUtil, ReferrerAuthenticator}
+import util.Directory._
+import util.Implicits._
+import service._
+import org.eclipse.jgit.api.Git
+import jp.sf.amateras.scalatra.forms._
+import org.eclipse.jgit.transport.RefSpec
+import org.apache.commons.io.FileUtils
+import scala.collection.JavaConverters._
+import org.eclipse.jgit.lib.PersonIdent
+import org.eclipse.jgit.api.MergeCommand.FastForwardMode
+import service.IssuesService._
+import service.PullRequestService._
+import util.JGitUtil.DiffInfo
+import scala.Some
+import service.RepositoryService.RepositoryTreeNode
+import util.JGitUtil.CommitInfo
+
+class PullRequestsController extends PullRequestsControllerBase
+  with RepositoryService with AccountService with IssuesService with PullRequestService with MilestonesService with ActivityService
+  with ReferrerAuthenticator with CollaboratorsAuthenticator
+
+trait PullRequestsControllerBase extends ControllerBase {
+  self: RepositoryService with IssuesService with MilestonesService with ActivityService with PullRequestService
+    with ReferrerAuthenticator with CollaboratorsAuthenticator =>
+
+  val pullRequestForm = mapping(
+    "title"           -> trim(label("Title"  , text(required, maxlength(100)))),
+    "content"         -> trim(label("Content", optional(text()))),
+    "targetUserName"  -> trim(text(required, maxlength(100))),
+    "targetBranch"    -> trim(text(required, maxlength(100))),
+    "requestUserName" -> trim(text(required, maxlength(100))),
+    "requestBranch"   -> trim(text(required, maxlength(100))),
+    "commitIdFrom"    -> trim(text(required, maxlength(40))),
+    "commitIdTo"      -> trim(text(required, maxlength(40)))
+  )(PullRequestForm.apply)
+
+  val mergeForm = mapping(
+    "message" -> trim(label("Message", text(required)))
+  )(MergeForm.apply)
+
+  case class PullRequestForm(
+    title: String,
+    content: Option[String],
+    targetUserName: String,
+    targetBranch: String,
+    requestUserName: String,
+    requestBranch: String,
+    commitIdFrom: String,
+    commitIdTo: String)
+
+  case class MergeForm(message: String)
+
+  get("/:owner/:repository/pulls")(referrersOnly { repository =>
+    searchPullRequests(None, repository)
+  })
+
+  get("/:owner/:repository/pulls/:userName")(referrersOnly { repository =>
+    searchPullRequests(Some(params("userName")), repository)
+  })
+
+  get("/:owner/:repository/pull/:id")(referrersOnly { repository =>
+    val owner   = repository.owner
+    val name    = repository.name
+    val issueId = params("id").toInt
+
+    getPullRequest(owner, name, issueId) map { case(issue, pullreq) =>
+      JGitUtil.withGit(getRepositoryDir(owner, name)){ git =>
+        val requestCommitId = git.getRepository.resolve(pullreq.requestBranch)
+
+        val (commits, diffs) =
+          getRequestCompareInfo(owner, name, pullreq.commitIdFrom, owner, name, pullreq.commitIdTo)
+
+        pulls.html.pullreq(
+          issue, pullreq,
+          getComments(owner, name, issueId.toInt),
+          (getCollaborators(owner, name) :+ owner).sorted,
+          getMilestonesWithIssueCount(owner, name),
+          commits,
+          diffs,
+          requestCommitId.getName,
+          if(issue.closed){
+            false
+          } else {
+            checkConflict(owner, name, pullreq.branch, owner, name, pullreq.requestBranch)
+          },
+          hasWritePermission(owner, name, context.loginAccount),
+          repository,
+          s"${baseUrl}${context.path}/git/${pullreq.requestUserName}/${pullreq.requestRepositoryName}.git")
+      }
+
+    } getOrElse NotFound
+  })
+
+  post("/:owner/:repository/pull/:id/merge", mergeForm)(collaboratorsOnly { (form, repository) =>
+    LockUtil.lock(s"${repository.owner}/${repository.name}/merge"){
+      val issueId = params("id").toInt
+
+      getPullRequest(repository.owner, repository.name, issueId).map { case (issue, pullreq) =>
+        val remote = getRepositoryDir(repository.owner, repository.name)
+        val tmpdir = new java.io.File(getTemporaryDir(repository.owner, repository.name), s"merge-${issueId}")
+        val git    = Git.cloneRepository.setDirectory(tmpdir).setURI(remote.toURI.toString).call
+
+        try {
+          // mark issue as merged and close.
+          val loginAccount = context.loginAccount.get
+          createComment(repository.owner, repository.name, loginAccount.userName, issueId, "Merge", "merge")
+          createComment(repository.owner, repository.name, loginAccount.userName, issueId, "Close", "close")
+          updateClosed(repository.owner, repository.name, issueId, true)
+          recordMergeActivity(repository.owner, repository.name, loginAccount.userName, issueId, form.message)
+
+          // fetch pull request to working repository
+          val pullRequestBranchName = s"gitbucket-pullrequest-${issueId}"
+
+          git.fetch
+            .setRemote(getRepositoryDir(repository.owner, repository.name).toURI.toString)
+            .setRefSpecs(new RefSpec(s"refs/pull/${issueId}/head:refs/heads/${pullRequestBranchName}")).call
+
+          // merge pull request
+          git.checkout.setName(pullreq.branch).call
+
+          val result = git.merge
+            .include(git.getRepository.resolve(pullRequestBranchName))
+            .setFastForward(FastForwardMode.NO_FF)
+            .setCommit(false)
+            .call
+
+          if(result.getConflicts != null){
+            throw new RuntimeException("This pull request can't merge automatically.")
+          }
+
+          // merge commit
+          git.getRepository.writeMergeCommitMsg(
+            s"Merge pull request #${issueId} from ${pullreq.requestUserName}/${pullreq.requestRepositoryName}\n"
+            + form.message)
+
+          git.commit
+            .setCommitter(new PersonIdent(loginAccount.userName, loginAccount.mailAddress))
+            .call
+
+          // push
+          git.push.call
+
+          val (commits, _) = getRequestCompareInfo(repository.owner, repository.name, pullreq.commitIdFrom,
+            pullreq.requestUserName, pullreq.requestRepositoryName, pullreq.commitIdTo)
+
+          commits.flatten.foreach { commit =>
+            if(!existsCommitId(repository.owner, repository.name, commit.id)){
+              insertCommitId(repository.owner, repository.name, commit.id)
+            }
+          }
+
+          redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}")
+
+        } finally {
+          git.getRepository.close
+          FileUtils.deleteDirectory(tmpdir)
+        }
+      } getOrElse NotFound
+    }
+  })
+
+  /**
+   * Checks whether conflict will be caused in merging.
+   * Returns true if conflict will be caused.
+   */
+  private def checkConflict(userName: String, repositoryName: String, branch: String,
+                            requestUserName: String, requestRepositoryName: String, requestBranch: String): Boolean = {
+    // TODO Are there more quick way?
+    LockUtil.lock(s"${userName}/${repositoryName}/merge-check"){
+      val remote = getRepositoryDir(userName, repositoryName)
+      val tmpdir = new java.io.File(getTemporaryDir(userName, repositoryName), "merge-check")
+      if(tmpdir.exists()){
+        FileUtils.deleteDirectory(tmpdir)
+      }
+
+      val git = Git.cloneRepository.setDirectory(tmpdir).setURI(remote.toURI.toString).call
+      try {
+        git.checkout.setName(branch).call
+
+        git.fetch
+          .setRemote(getRepositoryDir(requestUserName, requestRepositoryName).toURI.toString)
+          .setRefSpecs(new RefSpec(s"refs/heads/${branch}:refs/heads/${requestBranch}")).call
+
+        val result = git.merge
+          .include(git.getRepository.resolve("FETCH_HEAD"))
+          .setCommit(false).call
+
+        result.getConflicts != null
+
+      } finally {
+        git.getRepository.close
+        FileUtils.deleteDirectory(tmpdir)
+      }
+    }
+  }
+
+  get("/:owner/:repository/compare")(collaboratorsOnly { forkedRepository =>
+    (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)
+          ){ (oldGit, newGit) =>
+            val oldBranch = JGitUtil.getDefaultBranch(oldGit, originRepository).get._2
+            val newBranch = JGitUtil.getDefaultBranch(newGit, forkedRepository).get._2
+
+            redirect(s"${context.path}/${forkedRepository.owner}/${forkedRepository.name}/compare/${originUserName}:${oldBranch}...${newBranch}")
+          }
+        } getOrElse NotFound
+      }
+      case _ => {
+        JGitUtil.withGit(getRepositoryDir(forkedRepository.owner, forkedRepository.name)){ git =>
+          val defaultBranch = JGitUtil.getDefaultBranch(git, forkedRepository).get._2
+          redirect(s"${context.path}/${forkedRepository.owner}/${forkedRepository.name}/compare/${defaultBranch}...${defaultBranch}")
+        }
+      }
+    }
+  })
+
+  get("/:owner/:repository/compare/*...*")(collaboratorsOnly { repository =>
+    val Seq(origin, forked) = multiParams("splat")
+    val (originOwner, tmpOriginBranch) = parseCompareIdentifie(origin, repository.owner)
+    val (forkedOwner, tmpForkedBranch) = parseCompareIdentifie(forked, repository.owner)
+
+    (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)
+        ){ case (oldGit, newGit) =>
+          val originBranch = JGitUtil.getDefaultBranch(oldGit, originRepository, tmpOriginBranch).get._2
+          val forkedBranch = JGitUtil.getDefaultBranch(newGit, forkedRepository, tmpForkedBranch).get._2
+
+          val forkedId = getForkedCommitId(oldGit, newGit,
+            originOwner, repository.name, originBranch,
+            forkedOwner, repository.name, forkedBranch)
+
+          val oldId = oldGit.getRepository.resolve(forkedId)
+          val newId = newGit.getRepository.resolve(forkedBranch)
+
+          val (commits, diffs) = getRequestCompareInfo(
+            originOwner, repository.name, oldId.getName,
+            forkedOwner, repository.name, newId.getName)
+
+          pulls.html.compare(
+            commits,
+            diffs,
+            repository.repository.originUserName.map { userName =>
+              getRepositoryNames(getForkedRepositoryTree(userName, repository.name))
+            } getOrElse Nil,
+            originBranch,
+            forkedBranch,
+            oldId.getName,
+            newId.getName,
+            checkConflict(originOwner, repository.name, originBranch, forkedOwner, repository.name, forkedBranch),
+            repository,
+            originRepository,
+            forkedRepository)
+        }
+      }
+      case _ => NotFound
+    }
+  })
+
+  post("/:owner/:repository/pulls/new", pullRequestForm)(referrersOnly { (form, repository) =>
+    val loginUserName = context.loginAccount.get.userName
+
+    val issueId = createIssue(
+      owner            = repository.owner,
+      repository       = repository.name,
+      loginUser        = loginUserName,
+      title            = form.title,
+      content          = form.content,
+      assignedUserName = None,
+      milestoneId      = None,
+      isPullRequest    = true)
+
+    createPullRequest(
+      originUserName        = repository.owner,
+      originRepositoryName  = repository.name,
+      issueId               = issueId,
+      originBranch          = form.targetBranch,
+      requestUserName       = form.requestUserName,
+      requestRepositoryName = repository.name,
+      requestBranch         = form.requestBranch,
+      commitIdFrom          = form.commitIdFrom,
+      commitIdTo            = form.commitIdTo)
+
+    // fetch requested branch
+    JGitUtil.withGit(getRepositoryDir(repository.owner, repository.name)){ git =>
+      git.fetch
+        .setRemote(getRepositoryDir(form.requestUserName, repository.name).toURI.toString)
+        .setRefSpecs(new RefSpec(s"refs/heads/${form.requestBranch}:refs/pull/${issueId}/head"))
+        .call
+    }
+
+    recordPullRequestActivity(repository.owner, repository.name, loginUserName, issueId, form.title)
+
+    redirect(s"/${repository.owner}/${repository.name}/pulls/${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.
+   *
+   * - "owner:branch" to ("owner", "branch")
+   * - "branch" to ("defaultOwner", "branch")
+   */
+  private def parseCompareIdentifie(value: String, defaultOwner: String): (String, String) =
+    if(value.contains(':')){
+      val array = value.split(":")
+      (array(0), array(1))
+    } else {
+      (defaultOwner, value)
+    }
+
+  /**
+   * Extracts all repository names from [[service.RepositoryService.RepositoryTreeNode]] as flat list.
+   */
+  private def getRepositoryNames(node: RepositoryTreeNode): List[String] =
+    node.owner :: node.children.map { child => getRepositoryNames(child) }.flatten
+
+  /**
+   * Returns the identifier of the root commit (or latest merge commit) of the specified branch.
+   */
+  private def getForkedCommitId(oldGit: Git, newGit: Git, userName: String, repositoryName: String, branch: String,
+      requestUserName: String, requestRepositoryName: String, requestBranch: String): String =
+    JGitUtil.getCommitLogs(newGit, requestBranch, true){ commit =>
+      existsCommitId(userName, repositoryName, commit.getName) &&
+        JGitUtil.getBranchesOfCommit(oldGit, commit.getName).contains(branch)
+    }.head.id
+
+  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)
+    ){ (oldGit, newGit) =>
+      val oldId = oldGit.getRepository.resolve(branch)
+      val newId = newGit.getRepository.resolve(requestCommitId)
+
+      val commits = newGit.log.addRange(oldId, newId).call.iterator.asScala.map { revCommit =>
+        new CommitInfo(revCommit)
+      }.toList.splitWith{ (commit1, commit2) =>
+        view.helpers.date(commit1.time) == view.helpers.date(commit2.time)
+      }
+
+      val diffs = JGitUtil.getDiffs(newGit, oldId.getName, newId.getName, true)
+
+      (commits, diffs)
+    }
+  }
+
+  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"
+
+    // retrieve search condition
+    val condition = if(request.getQueryString == null){
+      session.get(sessionKey).getOrElse(IssueSearchCondition()).asInstanceOf[IssueSearchCondition]
+    } else IssueSearchCondition(request)
+
+    session.put(sessionKey, condition)
+
+    pulls.html.list(
+      searchIssue(condition, filterUser, true, (page - 1) * PullRequestLimit, PullRequestLimit, owner -> repoName),
+      getPullRequestCount(condition.state == "closed", Some(owner, 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
@@ -45,7 +45,15 @@ trait RepositorySettingsControllerBase extends ControllerBase with FlashMapSuppo
   * Save the repository options.
   */
  post("/:owner/:repository/settings/options", optionsForm)(ownerOnly { (form, repository) =>
-    saveRepositoryOptions(repository.owner, repository.name, form.description, form.defaultBranch, form.isPrivate)
+    saveRepositoryOptions(
+      repository.owner,
+      repository.name,
+      form.description,
+      form.defaultBranch,
+      repository.repository.parentUserName.map { _ =>
+        repository.repository.isPrivate
+      } getOrElse form.isPrivate
+    )
    flash += "info" -> "Repository settings has been updated."
    redirect(s"/${repository.owner}/${repository.name}/settings/options")
  })
--- a/src/main/scala/app/RepositoryViewerController.scala
+++ b/src/main/scala/app/RepositoryViewerController.scala
@@ -37,49 +37,29 @@ trait RepositoryViewerControllerBase extends ControllerBase {
    fileList(_)
  })
  
-  /**
-   * Displays the file list of the repository root and the specified branch.
-   */
-  get("/:owner/:repository/tree/:id")(referrersOnly {
-    fileList(_, params("id"))
-  })
-  
  /**
   * Displays the file list of the specified path and branch.
   */
-  get("/:owner/:repository/tree/:id/*")(referrersOnly {
-    fileList(_, params("id"), multiParams("splat").head)
-  })
-  
-  /**
-   * Displays the commit list of the specified branch.
-   */
-  get("/:owner/:repository/commits/:branch")(referrersOnly { repository =>
-    val branchName = params("branch")
-    val page       = params.getOrElse("page", "1").toInt
-    JGitUtil.withGit(getRepositoryDir(repository.owner, repository.name)){ git =>
-      JGitUtil.getCommitLog(git, branchName, page, 30) match {
-        case Right((logs, hasNext)) =>
-          repo.html.commits(Nil, branchName, repository, logs.splitWith{ (commit1, commit2) =>
-            view.helpers.date(commit1.time) == view.helpers.date(commit2.time)
-          }, page, hasNext)
-        case Left(_) => NotFound
-      }
+  get("/:owner/:repository/tree/*")(referrersOnly { repository =>
+    val (id, path) = splitPath(repository, multiParams("splat").head)
+    if(path.isEmpty){
+      fileList(repository, id)
+    } else {
+      fileList(repository, id, path)
    }
  })
  
  /**
   * Displays the commit list of the specified resource.
   */
-  get("/:owner/:repository/commits/:branch/*")(referrersOnly { repository =>
-    val branchName = params("branch")
-    val path       = multiParams("splat").head //.replaceFirst("^tree/.+?/", "")
-    val page       = params.getOrElse("page", "1").toInt
+  get("/:owner/:repository/commits/*")(referrersOnly { repository =>
+    val (branchName, path) = splitPath(repository, multiParams("splat").head)
+    val page = params.getOrElse("page", "1").toInt

    JGitUtil.withGit(getRepositoryDir(repository.owner, repository.name)){ git =>
      JGitUtil.getCommitLog(git, branchName, page, 30, path) match {
        case Right((logs, hasNext)) =>
-          repo.html.commits(path.split("/").toList, branchName, repository,
+          repo.html.commits(if(path.isEmpty) Nil else path.split("/").toList, branchName, repository,
            logs.splitWith{ (commit1, commit2) =>
              view.helpers.date(commit1.time) == view.helpers.date(commit2.time)
            }, page, hasNext)
@@ -91,10 +71,9 @@ trait RepositoryViewerControllerBase extends ControllerBase {
  /**
   * Displays the file content of the specified branch or commit.
   */
-  get("/:owner/:repository/blob/:id/*")(referrersOnly { repository =>
-    val id         = params("id") // branch name or commit id
-    val raw        = params.get("raw").getOrElse("false").toBoolean
-    val path       = multiParams("splat").head //.replaceFirst("^tree/.+?/", "")
+  get("/:owner/:repository/blob/*")(referrersOnly { repository =>
+    val (id, path) = splitPath(repository, multiParams("splat").head)
+    val raw = params.get("raw").getOrElse("false").toBoolean

    JGitUtil.withGit(getRepositoryDir(repository.owner, repository.name)){ git =>
      val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))
@@ -202,7 +181,25 @@ trait RepositoryViewerControllerBase extends ControllerBase {
      BadRequest
    }
  })
+
+  get("/:owner/:repository/network/members")(referrersOnly { repository =>
+    repo.html.forked(
+      getForkedRepositoryTree(
+        repository.repository.originUserName.getOrElse(repository.owner),
+        repository.repository.originRepositoryName.getOrElse(repository.name)),
+      repository)
+  })
  
+  private def splitPath(repository: service.RepositoryService.RepositoryInfo, path: String): (String, String) = {
+    val id = repository.branchList.collectFirst {
+      case branch if(path == branch || path.startsWith(branch + "/")) => branch
+    } orElse repository.tags.collectFirst {
+      case tag if(path == tag.name || path.startsWith(tag.name + "/")) => tag.name
+    } orElse Some(path) get
+
+    (id, path.substring(id.length).replaceFirst("^/", ""))
+  }
+
  /**
   * Provides HTML of the file list.
   * 
@@ -218,7 +215,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
      JGitUtil.withGit(getRepositoryDir(repository.owner, repository.name)){ git =>
        val revisions = Seq(if(revstr.isEmpty) repository.repository.defaultBranch else revstr, repository.branchList.head)
        // get specified commit
-        revisions.map { rev => (git.getRepository.resolve(rev), rev)}.find(_._1 != null).map { case (objectId, revision) =>
+      JGitUtil.getDefaultBranch(git, repository, revstr).map { case (objectId, revision) =>
          val revCommit = JGitUtil.getRevCommitFromId(git, objectId)

          // get files
--- a/src/main/scala/app/SearchController.scala
+++ b/src/main/scala/app/SearchController.scala
@@ -22,7 +22,7 @@ trait SearchControllerBase extends ControllerBase { self: RepositoryService
  case class SearchForm(query: String, owner: String, repository: String)

  post("/search", searchForm){ form =>
-    redirect(s"${form.owner}/${form.repository}/search?q=${StringUtil.urlEncode(form.query)}")
+    redirect(s"/${form.owner}/${form.repository}/search?q=${StringUtil.urlEncode(form.query)}")
  }

  get("/:owner/:repository/search")(referrersOnly { repository =>
--- a/src/main/scala/app/WikiController.scala
+++ b/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)
    }
  })
  
@@ -105,9 +105,10 @@ trait WikiControllerBase extends ControllerBase {
  })
  
  get("/:owner/:repository/wiki/:page/_delete")(collaboratorsOnly { repository =>
-      val pageName = StringUtil.urlDecode(params("page"))
+    val pageName = StringUtil.urlDecode(params("page"))
+    val account  = context.loginAccount.get
    
-    deleteWikiPage(repository.owner, repository.name, pageName, context.loginAccount.get.userName, s"Delete ${pageName}")
+    deleteWikiPage(repository.owner, repository.name, pageName, account.userName, account.mailAddress, s"Delete ${pageName}")
    updateLastActivityDate(repository.owner, repository.name)

    redirect(s"/${repository.owner}/${repository.name}/wiki")