(refs #101)Modification to add rename repository name.

src/main/scala/app/CreateRepositoryController.scala

@@ -113,54 +113,62 @@ trait CreateRepositoryControllerBase extends ControllerBase {
     val loginUserName  = loginAccount.userName
 
     LockUtil.lock(s"${loginUserName}/${repository.name}/create"){
-      if(getRepository(loginUserName, repository.name, baseUrl).isEmpty){
+      if(repository.owner == loginUserName){
-        // Insert to the database at first
+        // redirect to the repository
-        val originUserName = repository.repository.originUserName.getOrElse(repository.owner)
+        redirect(s"/${repository.owner}/${repository.name}")
-        val originRepositoryName = repository.repository.originRepositoryName.getOrElse(repository.name)
+      } else {
+        getForkedRepositories(repository.owner, repository.name).find(_._1 == loginUserName).map { case (owner, name) =>
+          // redirect to the repository
+          redirect(s"/${owner}/${name}")
+        } getOrElse {
+          // Insert to the database at first
+          val originUserName = repository.repository.originUserName.getOrElse(repository.owner)
+          val originRepositoryName = repository.repository.originRepositoryName.getOrElse(repository.name)
 
-        createRepository(
+          createRepository(
-          repositoryName       = repository.name,
+            repositoryName       = repository.name,
-          userName             = loginUserName,
+            userName             = loginUserName,
-          description          = repository.repository.description,
+            description          = repository.repository.description,
-          isPrivate            = repository.repository.isPrivate,
+            isPrivate            = repository.repository.isPrivate,
-          originRepositoryName = Some(originRepositoryName),
+            originRepositoryName = Some(originRepositoryName),
-          originUserName       = Some(originUserName),
+            originUserName       = Some(originUserName),
-          parentRepositoryName = Some(repository.name),
+            parentRepositoryName = Some(repository.name),
-          parentUserName       = Some(repository.owner)
+            parentUserName       = Some(repository.owner)
-        )
+          )
 
-        // Insert default labels
+          // Insert default labels
-        insertDefaultLabels(loginUserName, repository.name)
+          insertDefaultLabels(loginUserName, repository.name)
 
-        // clone repository actually
+          // clone repository actually
-        JGitUtil.cloneRepository(
+          JGitUtil.cloneRepository(
-          getRepositoryDir(repository.owner, repository.name),
+            getRepositoryDir(repository.owner, repository.name),
-          getRepositoryDir(loginUserName, repository.name))
+            getRepositoryDir(loginUserName, repository.name))
 
-        // Create Wiki repository
+          // Create Wiki repository
-        JGitUtil.cloneRepository(
+          JGitUtil.cloneRepository(
-          getWikiRepositoryDir(repository.owner, repository.name),
+            getWikiRepositoryDir(repository.owner, repository.name),
-          getWikiRepositoryDir(loginUserName, repository.name))
+            getWikiRepositoryDir(loginUserName, repository.name))
 
-        // insert commit id
+          // insert commit id
-        using(Git.open(getRepositoryDir(loginUserName, repository.name))){ git =>
+          using(Git.open(getRepositoryDir(loginUserName, repository.name))){ git =>
-          JGitUtil.getRepositoryInfo(loginUserName, repository.name, baseUrl).branchList.foreach { branch =>
+            JGitUtil.getRepositoryInfo(loginUserName, repository.name, baseUrl).branchList.foreach { branch =>
-            JGitUtil.getCommitLog(git, branch) match {
+              JGitUtil.getCommitLog(git, branch) match {
-              case Right((commits, _)) => commits.foreach { commit =>
+                case Right((commits, _)) => commits.foreach { commit =>
-                if(!existsCommitId(loginUserName, repository.name, commit.id)){
+                  if(!existsCommitId(loginUserName, repository.name, commit.id)){
-                  insertCommitId(loginUserName, repository.name, commit.id)
+                    insertCommitId(loginUserName, repository.name, commit.id)
+                  }
                 }
+                case Left(_) => ???
               }
-              case Left(_) => ???
             }
           }
-        }
 
-        // Record activity
+          // Record activity
-        recordForkActivity(repository.owner, repository.name, loginUserName)
+          recordForkActivity(repository.owner, repository.name, loginUserName)
+          // redirect to the repository
+          redirect(s"/${loginUserName}/${repository.name}")
+        }
       }
-      // redirect to the repository
-      redirect("/%s/%s".format(loginUserName, repository.name))
     }
   })
 

src/main/scala/app/PullRequestsController.scala

@@ -31,14 +31,15 @@ trait PullRequestsControllerBase extends ControllerBase {
   private val logger = LoggerFactory.getLogger(classOf[PullRequestsControllerBase])
 
   val pullRequestForm = mapping(
-    "title"           -> trim(label("Title"  , text(required, maxlength(100)))),
+    "title"                 -> trim(label("Title"  , text(required, maxlength(100)))),
-    "content"         -> trim(label("Content", optional(text()))),
+    "content"               -> trim(label("Content", optional(text()))),
-    "targetUserName"  -> trim(text(required, maxlength(100))),
+    "targetUserName"        -> trim(text(required, maxlength(100))),
-    "targetBranch"    -> trim(text(required, maxlength(100))),
+    "targetBranch"          -> trim(text(required, maxlength(100))),
-    "requestUserName" -> trim(text(required, maxlength(100))),
+    "requestUserName"       -> trim(text(required, maxlength(100))),
-    "requestBranch"   -> trim(text(required, maxlength(100))),
+    "requestRepositoryName" -> trim(text(required, maxlength(100))),
-    "commitIdFrom"    -> trim(text(required, maxlength(40))),
+    "requestBranch"         -> trim(text(required, maxlength(100))),
-    "commitIdTo"      -> trim(text(required, maxlength(40)))
+    "commitIdFrom"          -> trim(text(required, maxlength(40))),
+    "commitIdTo"            -> trim(text(required, maxlength(40)))
   )(PullRequestForm.apply)
 
   val mergeForm = mapping(
@@ -51,6 +52,7 @@ trait PullRequestsControllerBase extends ControllerBase {
     targetUserName: String,
     targetBranch: String,
     requestUserName: String,
+    requestRepositoryName: String,
     requestBranch: String,
     commitIdFrom: String,
     commitIdTo: String)
@@ -213,73 +215,85 @@ trait PullRequestsControllerBase extends ControllerBase {
     }
   })
 
-  get("/:owner/:repository/compare/*...*")(referrersOnly { repository =>
+  get("/:owner/:repository/compare/*...*")(referrersOnly { forkedRepository =>
     val Seq(origin, forked) = multiParams("splat")
-    val (originOwner, tmpOriginBranch) = parseCompareIdentifie(origin, repository.owner)
+    val (originOwner, tmpOriginBranch) = parseCompareIdentifie(origin, forkedRepository.owner)
-    val (forkedOwner, tmpForkedBranch) = parseCompareIdentifie(forked, repository.owner)
+    val (forkedOwner, tmpForkedBranch) = parseCompareIdentifie(forked, forkedRepository.owner)
 
-    (getRepository(originOwner, repository.name, baseUrl),
+    (for(
-     getRepository(forkedOwner, repository.name, baseUrl)) match {
+      originRepositoryName <- if(originOwner == forkedOwner){
-      case (Some(originRepository), Some(forkedRepository)) => {
+        Some(forkedRepository.name)
-        using(
+      } else {
-          Git.open(getRepositoryDir(originOwner, repository.name)),
+        forkedRepository.repository.originRepositoryName.orElse {
-          Git.open(getRepositoryDir(forkedOwner, repository.name))
+          getForkedRepositories(forkedRepository.owner, forkedRepository.name).find(_._1 == originOwner).map(_._2)
-        ){ 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 =>
-              userName :: getForkedRepositories(userName, repository.name)
-            } getOrElse List(repository.owner),
-            originBranch,
-            forkedBranch,
-            oldId.getName,
-            newId.getName,
-            repository,
-            originRepository,
-            forkedRepository,
-            hasWritePermission(repository.owner, repository.name, context.loginAccount))
         }
+      };
+      originRepository <- getRepository(originOwner, originRepositoryName, baseUrl)
+    ) yield {
+      using(
+        Git.open(getRepositoryDir(originRepository.owner, originRepository.name)),
+        Git.open(getRepositoryDir(forkedRepository.owner, forkedRepository.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,
+          originRepository.owner, originRepository.name, originBranch,
+          forkedRepository.owner, forkedRepository.name, forkedBranch)
+
+        val oldId = oldGit.getRepository.resolve(forkedId)
+        val newId = newGit.getRepository.resolve(forkedBranch)
+
+        val (commits, diffs) = getRequestCompareInfo(
+          originRepository.owner, originRepository.name, oldId.getName,
+          forkedRepository.owner, forkedRepository.name, newId.getName)
+
+        pulls.html.compare(
+          commits,
+          diffs,
+          (forkedRepository.repository.originUserName, forkedRepository.repository.originRepositoryName) match {
+            case (Some(userName), Some(repositoryName)) => (userName, repositoryName) :: getForkedRepositories(userName, repositoryName)
+            case _ => (forkedRepository.owner, forkedRepository.name) :: getForkedRepositories(forkedRepository.owner, forkedRepository.name)
+          },
+          originBranch,
+          forkedBranch,
+          oldId.getName,
+          newId.getName,
+          forkedRepository,
+          originRepository,
+          forkedRepository,
+          hasWritePermission(forkedRepository.owner, forkedRepository.name, context.loginAccount))
       }
-      case _ => NotFound
+    }) getOrElse NotFound
-    }
   })
 
-  ajaxGet("/:owner/:repository/compare/*...*/mergecheck")(collaboratorsOnly { repository =>
+  ajaxGet("/:owner/:repository/compare/*...*/mergecheck")(collaboratorsOnly { forkedRepository =>
     val Seq(origin, forked) = multiParams("splat")
-    val (originOwner, tmpOriginBranch) = parseCompareIdentifie(origin, repository.owner)
+    val (originOwner, tmpOriginBranch) = parseCompareIdentifie(origin, forkedRepository.owner)
-    val (forkedOwner, tmpForkedBranch) = parseCompareIdentifie(forked, repository.owner)
+    val (forkedOwner, tmpForkedBranch) = parseCompareIdentifie(forked, forkedRepository.owner)
 
-    (getRepository(originOwner, repository.name, baseUrl),
+    (for(
-      getRepository(forkedOwner, repository.name, baseUrl)) match {
+      originRepositoryName <- if(originOwner == forkedOwner){
-      case (Some(originRepository), Some(forkedRepository)) => {
+        Some(forkedRepository.name)
-        using(
+      } else {
-          Git.open(getRepositoryDir(originOwner, repository.name)),
+        forkedRepository.repository.originRepositoryName.orElse {
-          Git.open(getRepositoryDir(forkedOwner, repository.name))
+          getForkedRepositories(forkedRepository.owner, forkedRepository.name).find(_._1 == originOwner).map(_._2)
-        ){ case (oldGit, newGit) =>
-          val originBranch = JGitUtil.getDefaultBranch(oldGit, originRepository, tmpOriginBranch).get._2
-          val forkedBranch = JGitUtil.getDefaultBranch(newGit, forkedRepository, tmpForkedBranch).get._2
-
-          pulls.html.mergecheck(
-            checkConflict(originOwner, repository.name, originBranch, forkedOwner, repository.name, forkedBranch))
         }
+      };
+      originRepository <- getRepository(originOwner, originRepositoryName, baseUrl)
+    ) yield {
+      using(
+        Git.open(getRepositoryDir(originRepository.owner, originRepository.name)),
+        Git.open(getRepositoryDir(forkedRepository.owner, forkedRepository.name))
+      ){ case (oldGit, newGit) =>
+        val originBranch = JGitUtil.getDefaultBranch(oldGit, originRepository, tmpOriginBranch).get._2
+        val forkedBranch = JGitUtil.getDefaultBranch(newGit, forkedRepository, tmpForkedBranch).get._2
+
+        pulls.html.mergecheck(
+          checkConflict(originRepository.owner, originRepository.name, originBranch,
+                        forkedRepository.owner, forkedRepository.name, forkedBranch))
       }
-      case _ => NotFound()
+    }) getOrElse NotFound
-    }
   })
 
   post("/:owner/:repository/pulls/new", pullRequestForm)(referrersOnly { (form, repository) =>
@@ -301,7 +315,7 @@ trait PullRequestsControllerBase extends ControllerBase {
       issueId               = issueId,
       originBranch          = form.targetBranch,
       requestUserName       = form.requestUserName,
-      requestRepositoryName = repository.name,
+      requestRepositoryName = form.requestRepositoryName,
       requestBranch         = form.requestBranch,
       commitIdFrom          = form.commitIdFrom,
       commitIdTo            = form.commitIdTo)
@@ -309,7 +323,7 @@ trait PullRequestsControllerBase extends ControllerBase {
     // fetch requested branch
     using(Git.open(getRepositoryDir(repository.owner, repository.name))){ git =>
       git.fetch
-        .setRemote(getRepositoryDir(form.requestUserName, repository.name).toURI.toString)
+        .setRemote(getRepositoryDir(form.requestUserName, form.requestRepositoryName).toURI.toString)
         .setRefSpecs(new RefSpec(s"refs/heads/${form.requestBranch}:refs/pull/${issueId}/head"))
         .call
     }
@@ -407,8 +421,7 @@ trait PullRequestsControllerBase extends ControllerBase {
   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) &&
+      existsCommitId(userName, repositoryName, commit.getName) && JGitUtil.getBranchesOfCommit(oldGit, commit.getName).contains(branch)
-        JGitUtil.getBranchesOfCommit(oldGit, commit.getName).contains(branch)
     }.head.id
 
   private def getRequestCompareInfo(userName: String, repositoryName: String, branch: String,

src/main/scala/app/RepositorySettingsController.scala

@@ -21,12 +21,13 @@ trait RepositorySettingsControllerBase extends ControllerBase with FlashMapSuppo
     with OwnerAuthenticator with UsersAuthenticator =>
 
   // for repository options
-  case class OptionsForm(description: Option[String], defaultBranch: String, isPrivate: Boolean)
+  case class OptionsForm(repositoryName: String, description: Option[String], defaultBranch: String, isPrivate: Boolean)
   
   val optionsForm = mapping(
-    "description"   -> trim(label("Description"    , optional(text()))),
+    "repositoryName" -> trim(label("Description"    , text(required, maxlength(40), identifier))), // TODO unique checking
-    "defaultBranch" -> trim(label("Default Branch" , text(required, maxlength(100)))),
+    "description"    -> trim(label("Description"    , optional(text()))),
-    "isPrivate"     -> trim(label("Repository Type", boolean()))
+    "defaultBranch"  -> trim(label("Default Branch" , text(required, maxlength(100)))),
+    "isPrivate"      -> trim(label("Repository Type", boolean()))
   )(OptionsForm.apply)
 
   // for collaborator addition
@@ -70,8 +71,21 @@ trait RepositorySettingsControllerBase extends ControllerBase with FlashMapSuppo
         repository.repository.isPrivate
       } getOrElse form.isPrivate
     )
+    // Change repository name
+    if(repository.name != form.repositoryName){
+      // Update database
+      renameRepository(repository.owner, repository.name, form.repositoryName)
+      // Move git repository
+      defining(getRepositoryDir(repository.owner, repository.name)){ dir =>
+        FileUtils.moveDirectory(dir, getRepositoryDir(repository.owner, form.repositoryName))
+      }
+      // Move wiki repository
+      defining(getWikiRepositoryDir(repository.owner, repository.name)){ dir =>
+        FileUtils.moveDirectory(dir, getWikiRepositoryDir(repository.owner, form.repositoryName))
+      }
+    }
     flash += "info" -> "Repository settings has been updated."
-    redirect(s"/${repository.owner}/${repository.name}/settings/options")
+    redirect(s"/${repository.owner}/${form.repositoryName}/settings/options")
   })
   
   /**

src/main/scala/service/RepositoryService.scala

@@ -39,6 +39,51 @@ trait RepositoryService { self: AccountService =>
     IssueId insert (userName, repositoryName, 0)
   }
 
+  def renameRepository(userName: String, oldRepositoryName: String, newRepositoryName: String): Unit = {
+    (Query(Repositories) filter { t => t.byRepository(userName, oldRepositoryName) } firstOption).map { repository =>
+      Repositories insert repository.copy(repositoryName = newRepositoryName)
+
+      val webHooks      = Query(WebHooks     ).filter(_.byRepository(userName, oldRepositoryName)).list
+      val milestones    = Query(Milestones   ).filter(_.byRepository(userName, oldRepositoryName)).list
+      val issueId       = Query(IssueId      ).filter(_.byRepository(userName, oldRepositoryName)).list
+      val issues        = Query(Issues       ).filter(_.byRepository(userName, oldRepositoryName)).list
+      val pullRequests  = Query(PullRequests ).filter(_.byRepository(userName, oldRepositoryName)).list
+      val labels        = Query(Labels       ).filter(_.byRepository(userName, oldRepositoryName)).list
+      val issueComments = Query(IssueComments).filter(_.byRepository(userName, oldRepositoryName)).list
+      val issueLabels   = Query(IssueLabels  ).filter(_.byRepository(userName, oldRepositoryName)).list
+      val collaborators = Query(Collaborators).filter(_.byRepository(userName, oldRepositoryName)).list
+      val commitLog     = Query(CommitLog    ).filter(_.byRepository(userName, oldRepositoryName)).list
+      val activities    = Query(Activities   ).filter(_.byRepository(userName, oldRepositoryName)).list
+
+      Repositories.filter { t =>
+        (t.originUserName is userName.bind) && (t.originRepositoryName is oldRepositoryName.bind)
+      }.map(_.originRepositoryName).update(newRepositoryName)
+
+      Repositories.filter { t =>
+        (t.parentUserName is userName.bind) && (t.parentRepositoryName is oldRepositoryName.bind)
+      }.map(_.parentRepositoryName).update(newRepositoryName)
+
+      PullRequests.filter { t =>
+        t.requestRepositoryName is oldRepositoryName.bind
+      }.map(_.requestRepositoryName).update(newRepositoryName)
+
+      deleteRepository(userName, oldRepositoryName)
+
+      WebHooks      .insertAll(webHooks      .map(_.copy(repositoryName = newRepositoryName)) :_*)
+      Milestones    .insertAll(milestones    .map(_.copy(repositoryName = newRepositoryName)) :_*)
+      IssueId       .insertAll(issueId       .map(_.copy(_2             = newRepositoryName)) :_*)
+      Issues        .insertAll(issues        .map(_.copy(repositoryName = newRepositoryName)) :_*)
+      PullRequests  .insertAll(pullRequests  .map(_.copy(repositoryName = newRepositoryName)) :_*)
+      IssueComments .insertAll(issueComments .map(_.copy(repositoryName = newRepositoryName)) :_*)
+      Labels        .insertAll(labels        .map(_.copy(repositoryName = newRepositoryName)) :_*)
+      IssueLabels   .insertAll(issueLabels   .map(_.copy(repositoryName = newRepositoryName)) :_*)
+      Collaborators .insertAll(collaborators .map(_.copy(repositoryName = newRepositoryName)) :_*)
+      CommitLog     .insertAll(commitLog     .map(_.copy(_2             = newRepositoryName)) :_*)
+      Activities    .insertAll(activities    .map(_.copy(repositoryName = newRepositoryName)) :_*)
+
+    }
+  }
+
   def deleteRepository(userName: String, repositoryName: String): Unit = {
     Activities    .filter(_.byRepository(userName, repositoryName)).delete
     CommitLog     .filter(_.byRepository(userName, repositoryName)).delete
@@ -207,11 +252,11 @@ trait RepositoryService { self: AccountService =>
     }.length).first
 
 
-  def getForkedRepositories(userName: String, repositoryName: String): List[String] =
+  def getForkedRepositories(userName: String, repositoryName: String): List[(String, String)] =
     Query(Repositories).filter { t =>
       (t.originUserName is userName.bind) && (t.originRepositoryName is repositoryName.bind)
     }
-    .sortBy(_.userName asc).map(_.userName).list
+    .sortBy(_.userName asc).map(t => t.userName ~ t.repositoryName).list
 
 }
 

src/main/twirl/pulls/compare.scala.html

@@ -1,6 +1,6 @@
 @(commits: Seq[Seq[util.JGitUtil.CommitInfo]],
   diffs: Seq[util.JGitUtil.DiffInfo],
-  members: List[String],
+  members: List[(String, String)],
   originId: String,
   forkedId: String,
   sourceId: String,
@@ -20,25 +20,25 @@
     </div>
     <div id="compare-edit" style="display: none;">
       <a href="#" id="cancel-condition-editing" class="pull-right"><i class="icon-remove-circle"></i></a>
-      @helper.html.dropdown(originRepository.owner + "/" + repository.name, "base fork") {
+      @helper.html.dropdown(originRepository.owner + "/" + originRepository.name, "base fork") {
-        @members.map { member =>
+        @members.map { case (owner, name) =>
-          <li><a href="#" class="origin-owner" data-name="@member">@helper.html.checkicon(member == originRepository.owner) @member/@repository.name</a></li>
+          <li><a href="#" class="origin-owner" data-owner="@owner" data-name="@name">@helper.html.checkicon(owner == originRepository.owner) @owner/@name</a></li>
         }
       }
       @helper.html.dropdown(originId, "base") {
         @originRepository.branchList.map { branch =>
-          <li><a href="#" class="origin-branch" data-name="@encodeRefName(branch)">@helper.html.checkicon(branch == originId) @branch</a></li>
+          <li><a href="#" class="origin-branch" data-branch="@encodeRefName(branch)">@helper.html.checkicon(branch == originId) @branch</a></li>
         }
       }
       ...
-      @helper.html.dropdown(forkedRepository.owner + "/" + repository.name, "head fork") {
+      @helper.html.dropdown(forkedRepository.owner + "/" + forkedRepository.name, "head fork") {
-        @members.map { member =>
+        @members.map { case (owner, name) =>
-          <li><a href="#" class="forked-owner" data-name="@member">@helper.html.checkicon(member == forkedRepository.owner) @member/@repository.name</a></li>
+          <li><a href="#" class="forked-owner" data-owner="@owner" data-name="@name">@helper.html.checkicon(owner == forkedRepository.owner) @owner/@name</a></li>
         }
       }
       @helper.html.dropdown(forkedId, "compare") {
         @forkedRepository.branchList.map { branch =>
-          <li><a href="#" class="forked-branch" data-name="@encodeRefName(branch)">@helper.html.checkicon(branch == forkedId) @branch</a></li>
+          <li><a href="#" class="forked-branch" data-branch="@encodeRefName(branch)">@helper.html.checkicon(branch == forkedId) @branch</a></li>
         }
       }
     </div>
@@ -49,7 +49,7 @@
     </div>
     <div id="pull-request-form" class="box" style="display: none;">
         <div class="box-content">
-          <form method="POST" action="@path/@originRepository.owner/@repository.name/pulls/new" validate="true">
+          <form method="POST" action="@path/@originRepository.owner/@originRepository.name/pulls/new" validate="true">
             <div style="width: 260px; position: absolute; margin-left: 635px;">
               <div class="check-conflict" style="display: none;">
                 <img src="@assets/common/images/indicator.gif"/> Checking...
@@ -62,6 +62,7 @@
               <input type="hidden" name="targetUserName" value="@originRepository.owner"/>
               <input type="hidden" name="targetBranch" value="@originId"/>
               <input type="hidden" name="requestUserName" value="@forkedRepository.owner"/>
+              <input type="hidden" name="requestRepositoryName" value="@forkedRepository.name"/>
               <input type="hidden" name="requestBranch" value="@forkedId"/>
               <input type="hidden" name="commitIdFrom" value="@sourceId"/>
               <input type="hidden" name="commitIdTo" value="@commitId"/>
@@ -104,14 +105,16 @@ $(function(){
 
     @if(members.isEmpty){
       location.href = '@url(repository)/compare/' +
-        $.trim($('i.icon-ok').parents('a.origin-branch').data('name')) + '...' +
+        $.trim($('i.icon-ok').parents('a.origin-branch').data('branch')) + '...' +
-        $.trim($('i.icon-ok').parents('a.forked-branch').data('name'));
+        $.trim($('i.icon-ok').parents('a.forked-branch').data('branch'));
     } else {
-      location.href = '@url(repository)/compare/' +
+      location.href = '@path/' +
-        $.trim($('i.icon-ok').parents('a.origin-owner' ).data('name')) + ':' +
+        $.trim($('i.icon-ok').parents('a.forked-owner' ).data('owner')) + '/' +
-        $.trim($('i.icon-ok').parents('a.origin-branch').data('name')) + '...' +
+        $.trim($('i.icon-ok').parents('a.forked-owner' ).data('name')) +'/compare/' +
-        $.trim($('i.icon-ok').parents('a.forked-owner' ).data('name')) + ':' +
+        $.trim($('i.icon-ok').parents('a.origin-owner' ).data('owner')) + ':' +
-        $.trim($('i.icon-ok').parents('a.forked-branch').data('name'));
+        $.trim($('i.icon-ok').parents('a.origin-branch').data('branch')) + '...' +
+        $.trim($('i.icon-ok').parents('a.forked-owner' ).data('owner')) + ':' +
+        $.trim($('i.icon-ok').parents('a.forked-branch').data('branch'));
     }
   });
 
@@ -129,15 +132,15 @@ $(function(){
 
     @if(members.isEmpty){
       checkConflict(
-        $.trim($('i.icon-ok').parents('a.origin-branch').data('name')),
+        $.trim($('i.icon-ok').parents('a.origin-branch').data('branch')),
-        $.trim($('i.icon-ok').parents('a.forked-branch').data('name'))
+        $.trim($('i.icon-ok').parents('a.forked-branch').data('branch'))
       );
     } else {
       checkConflict(
-        $.trim($('i.icon-ok').parents('a.origin-owner' ).data('name')) + ":" +
+        $.trim($('i.icon-ok').parents('a.origin-owner' ).data('owner')) + ":" +
-        $.trim($('i.icon-ok').parents('a.origin-branch').data('name')),
+        $.trim($('i.icon-ok').parents('a.origin-branch').data('branch')),
-        $.trim($('i.icon-ok').parents('a.forked-owner' ).data('name')) + ":" +
+        $.trim($('i.icon-ok').parents('a.forked-owner' ).data('owner')) + ":" +
-        $.trim($('i.icon-ok').parents('a.forked-branch').data('name'))
+        $.trim($('i.icon-ok').parents('a.forked-branch').data('branch'))
       );
     }
   }

src/main/twirl/repo/forked.scala.html

@@ -1,5 +1,5 @@
 @(originRepository: Option[service.RepositoryService.RepositoryInfo],
-  members: List[String],
+  members: List[(String, String)],
   repository: service.RepositoryService.RepositoryInfo)(implicit context: app.Context)
 @import context._
 @import view.helpers._
@@ -23,11 +23,11 @@
     }
     (origin)
   </div>
-  @members.map { owner =>
+  @members.map { case (owner, name) =>
     <div class="block">
       @avatar(owner, 20)
       <span@if(repository.owner == owner){ class="highlight"}>
-        <a href="@url(owner)">@owner</a> / <a href="@path/@owner/@repository.name">@repository.name</a>
+        <a href="@url(owner)">@owner</a> / <a href="@path/@owner/@name">@name</a>
       </span>
     </div>
   }

src/main/twirl/settings/options.scala.html

@@ -10,6 +10,10 @@
         <div class="box-header">Settings</div>
         <div class="box-content">
           <fieldset>
+            <label for="repositoryName" class="strong">Repository Name:</label>
+            <input type="text" name="repositoryName" id="repositoryName" value="@repository.name"/>
+          </fieldset>
+          <fieldset class="margin">
             <label for="description" class="strong">Description:</label>
             <input type="text" name="description" id="description" style="width: 600px;" value="@repository.repository.description"/>
           </fieldset>