Ready for 3.14 release

# Conflicts:
#	src/main/scala/gitbucket/core/service/WebHookService.scala
#	src/main/twirl/gitbucket/core/settings/edithooks.scala.html

.github/CONTRIBUTING.md

@@ -0,0 +1,7 @@
+# Guideline for Issues
+
+- At first, See [FAQ](https://github.com/gitbucket/gitbucket/wiki/FAQ) and check issues whether there is a same question or request in the past.
+- If you can't find same question and report, send it to [gitter room](https://gitter.im/gitbucket/gitbucket) before raising an issue.
+- We can also support in Japaneses other than English at [gitter room for Japanese](https://gitter.im/gitbucket/gitbucket_ja).
+- Write an issue in English. At least, write subject in English.
+- First priority of GitBucket is easy installation and reproduce GitHub behavior, so we might reject if your request is against it.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,19 @@
+### Before submitting an issue to Gitbucket I have first:
+
+- [] read the [contribution guidelines](https://github.com/gitbucket/gitbucket/blob/master/.github/CONTRIBUTING.md)
+- [] searched for similar already existing issue
+- [] read the documentation and [wiki](https://github.com/gitbucket/gitbucket/wiki) 
+
+*(if you have performed all the above, remove the paragraph and continue describing the issue with template below)*
+
+## Issue
+**Impacted version**: xxxx
+
+**Deployment mode**: *explain here how you use gitbucket : standalone app, under webcontainer (which one), with an http frontend (nginx, httpd, ...)*
+
+**Problem description**:
+- *be as explicit has you can*
+- *describe the problem and its symptoms*
+- *explain how to reproduce*
+- *attach whatever information that can help understanding the context (screen capture, log files)*
+- *do your best to use a correct english (re-read yourself)*

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,8 @@
+### Before submitting a pull-request to Gitbucket I have first:
+
+- [] read the [contribution guidelines](https://github.com/gitbucket/gitbucket/blob/master/.github/CONTRIBUTING.md)
+- [] rebased my branch over master
+- [] verified that project is compiling
+- [] verified that tests are passing
+- [] squashed my commits as appropriate *(keep several commits if it is relevant to understand the PR)*
+- [] [marked as closed](https://help.github.com/articles/closing-issues-via-commit-messages/) all issue ID that this PR should correct

CONTRIBUTING.md

@@ -1,7 +0,0 @@
-# Guideline for Issues
-
-- If you have any question about GitBucket, send it to [gitter room](https://gitter.im/gitbucket/gitbucket) before raise an issue.
-- Make sure check whether there is a same question or request in the past.
-- When raise a new issue, write subject in **English** at least.
-- We can also support in Japaneses other than English at [gitter room for Japanese](https://gitter.im/gitbucket/gitbucket_ja).
-- First priority of GitBucket is easy installation and reproduce GitHub behavior, so we might reject if your request is against it.

README.md

@@ -1,7 +1,10 @@
 GitBucket [![Gitter chat](https://badges.gitter.im/gitbucket/gitbucket.png)](https://gitter.im/gitbucket/gitbucket) [![Build Status](https://travis-ci.org/gitbucket/gitbucket.svg?branch=master)](https://travis-ci.org/gitbucket/gitbucket)
 =========
 
-GitBucket is a GitHub clone powered by Scala which has easy installation and high extensibility.
+GitBucket is a Git platform powered by Scala offering:
+- easy installation
+- high extensibility by plugins
+- API compatibility with Github
 
 Features
 --------
@@ -9,28 +12,21 @@ The current version of GitBucket provides a basic features below:
 
 - Public / Private Git repository (http and ssh access)
 - Repository viewer and online file editing
-- Repository search (Code and Issues)
 - Wiki
-- Issues
-- Fork / Pull request
+- Issues / Pull request
 - Email notification
-- Activity timeline
 - Simple user and group management with LDAP integration
-- Gravatar support
 - Plug-in system
 
-If you want to try the development version of GitBucket, see the documentation for developers at [Wiki](https://github.com/gitbucket/gitbucket/wiki).
+If you want to try the development version of GitBucket, see [Developer's Guide](https://github.com/gitbucket/gitbucket/blob/master/doc/how_to_run.md).
 
 Installation
 --------
+GitBucket requires **Java8**. You have to install beforehand when it's not installed.
 
 1. Download latest **gitbucket.war** from [the release page](https://github.com/gitbucket/gitbucket/releases).
 2. Deploy it to the Servlet 3.0 container such as Tomcat 7.x, Jetty 8.x, GlassFish 3.x or higher.
-3. Access **http://[hostname]:[port]/gitbucket/** using your web browser.
-
-If you are using Gitbucket behind a webserver please make sure you have increased the **client_max_body_size** (on nginx)
-
-The default administrator account is **root** and password is **root**.
+3. Access **http://[hostname]:[port]/gitbucket/** using your web browser and logged-in with **root** / **root**.
 
 or you can start GitBucket by `java -jar gitbucket.war` without servlet container. In this case, GitBucket URL is **http://[hostname]:8080/**. You can specify following options.
 
@@ -41,35 +37,7 @@ or you can start GitBucket by `java -jar gitbucket.war` without servlet containe
 
 To upgrade GitBucket, only replace gitbucket.war after stop GitBucket. All GitBucket data is stored in HOME/.gitbucket. So if you want to back up GitBucket data, copy this directory to the other disk.
 
-For Installation on Windows Server with IIS see [this wiki page](https://github.com/gitbucket/gitbucket/wiki/Installation-on-IIS-and-Helicontech-Zoo)
-
-### Mac OS X
-#### Installing Via Homebrew
-
-```
-$ brew install gitbucket
-==> Downloading https://github.com/takezoe/gitbucket/releases/download/1.10/gitbucket.war
-######################################################################## 100.0%
-==> Caveats
-Note: When using launchctl the port will be 8080.
-
-To have launchd start gitbucket at login:
-    ln -sfv /usr/local/opt/gitbucket/*.plist ~/Library/LaunchAgents
-Then to load gitbucket now:
-    launchctl load ~/Library/LaunchAgents/homebrew.mxcl.gitbucket.plist
-Or, if you don't want/need launchctl, you can just run:
-    java -jar /usr/local/opt/gitbucket/libexec/gitbucket.war
-==> Summary
-/usr/local/Cellar/gitbucket/1.10: 3 files, 42M, built in 11 seconds
-```
-
-#### Manual Installation
-On OS X, generate `gitbucket.plist` by [this script](https://raw.githubusercontent.com/gitbucket/gitbucket/master/contrib/macosx/makePlist) and copy it to `~/Library/LaunchAgents/`
-
-Run the following commands in `Terminal` to
-
-- start gitbucket: `launchctl load ~/Library/LaunchAgents/gitbucket.plist`
-- stop gitbucket: `launchctl unload ~/Library/LaunchAgents/gitbucket.plist`
+About installation on Mac or Windows Server (with IIS), configuration of Apache or Nginx and also integration with other tools or services such as Jenkins or Slack, see [Wiki](https://github.com/gitbucket/gitbucket/wiki).
 
 Plug-ins
 --------
@@ -91,10 +59,50 @@ Support
 - Make sure check whether there is a same question or request in the past.
 - When raise a new issue, write subject in **English** at least.
 - We can also support in Japaneses other than English at [gitter room for Japanese](https://gitter.im/gitbucket/gitbucket_ja).
-- First priority of GitBucket is easy installation and reproduce GitHub behavior, so we might reject if your request is against it.
+- First priority of GitBucket is easy installation and API compatibility with GitHub, so we might reject if your request is against it.
 
 Release Notes
 --------
+### 4.0 - 30 Apr 2016
+
+- MySQL and PostgreSQL support
+- Data export and import
+- Migration system has been switched to [solidbase](https://github.com/gitbucket/solidbase)
+
+### 3.14 - 30 Apr 2016
+
+- File attachment and search for wiki pages
+- New extension points to add menus
+- Content-Type of webhooks has been choosable
+
+### 3.13 - 1 Apr 2016
+- Refresh user interface for wide screen
+- Add `pull_request` key in list issues API for pull requests
+- Add `X-Hub-Signature` security to webhooks
+- Provide SHA-256 checksum for `gitbucket.war`
+
+### 3.12 - 27 Feb 2016
+- New GitHub UI
+- Improve mobile view
+- Improve printing style
+- Individual URL for pull request tabs
+- SSH host configuration is separated from HTTP base URL
+
+### 3.11 - 30 Jan 2016
+- Upgrade Scalatra to 2.4
+- Sidebar and Footer for Wiki
+- Branch protection and receive hook extension point for plug-in
+- Limit recent updated repositories list
+- Issue actions look-alike GitHub
+- Web API for labels
+- Requires Java 8
+
+### 3.10 - 30 Dec 2015
+- Move to Bootstrap3
+- New URL for raw contents (`raw/master/doc/activity.md` instead of `blob/master/doc/activity.md?raw=true`)
+- Update xsbt-web-plugin
+- Update H2 database
+
 ### 3.9 - 5 Dec 2015
 - GFM inline breaks support in Markdown
 - WebHook on create review comment is available
@@ -336,7 +344,3 @@ Release Notes
 
 ### 1.0 - 04 Jul 2013
 - This is a first public release
-
-Sponsors
---------
-[![IntelliJ IDEA](https://www.jetbrains.com/idea/docs/logo_intellij_idea.png)](https://www.jetbrains.com/idea/)

build.sbt

@@ -0,0 +1,163 @@
+val Organization = "gitbucket"
+val Name = "gitbucket"
+val GitBucketVersion = "3.14.0"
+val ScalatraVersion = "2.4.0"
+val JettyVersion = "9.3.6.v20151106"
+
+lazy val root = (project in file(".")).enablePlugins(SbtTwirl, JettyPlugin)
+
+sourcesInBase := false
+organization := Organization
+name := Name
+version := GitBucketVersion
+scalaVersion := "2.11.8"
+
+// dependency settings
+resolvers ++= Seq(
+  Classpaths.typesafeReleases,
+  "sonatype-snapshot" at "https://oss.sonatype.org/content/repositories/snapshots/"
+)
+libraryDependencies ++= Seq(
+  "org.scala-lang.modules"   %% "scala-java8-compat"           % "0.7.0",
+  "org.eclipse.jgit"          % "org.eclipse.jgit.http.server" % "4.1.1.201511131810-r",
+  "org.eclipse.jgit"          % "org.eclipse.jgit.archive"     % "4.1.1.201511131810-r",
+  "org.scalatra"             %% "scalatra"                     % ScalatraVersion,
+  "org.scalatra"             %% "scalatra-json"                % ScalatraVersion,
+  "org.json4s"               %% "json4s-jackson"               % "3.3.0",
+  "io.github.gitbucket"      %% "scalatra-forms"               % "1.0.0",
+  "commons-io"                % "commons-io"                   % "2.4",
+  "io.github.gitbucket"       % "markedj"                      % "1.0.8",
+  "org.apache.commons"        % "commons-compress"             % "1.10",
+  "org.apache.commons"        % "commons-email"                % "1.4",
+  "org.apache.httpcomponents" % "httpclient"                   % "4.5.1",
+  "org.apache.sshd"           % "apache-sshd"                  % "1.0.0",
+  "org.apache.tika"           % "tika-core"                    % "1.11",
+  "com.typesafe.slick"       %% "slick"                        % "2.1.0",
+  "com.novell.ldap"           % "jldap"                        % "2009-10-07",
+  "com.h2database"            % "h2"                           % "1.4.190",
+  "ch.qos.logback"            % "logback-classic"              % "1.1.1",
+  "com.mchange"               % "c3p0"                         % "0.9.5.2",
+  "com.typesafe"              % "config"                       % "1.3.0",
+  "com.typesafe.akka"        %% "akka-actor"                   % "2.3.14",
+  "fr.brouillard.oss.security.xhub" % "xhub4j-core"            % "1.0.0",
+  "com.enragedginger"        %% "akka-quartz-scheduler"        % "1.4.0-akka-2.3.x" exclude("c3p0","c3p0"),
+  "org.eclipse.jetty"         % "jetty-webapp"                 % JettyVersion     % "provided",
+  "javax.servlet"             % "javax.servlet-api"            % "3.1.0"          % "provided",
+  "junit"                     % "junit"                        % "4.12"           % "test",
+  "org.scalatra"             %% "scalatra-scalatest"           % ScalatraVersion  % "test",
+  "org.scalaz"               %% "scalaz-core"                  % "7.2.0"          % "test"
+)
+
+// Twirl settings
+play.twirl.sbt.Import.TwirlKeys.templateImports += "gitbucket.core._"
+
+// Compiler settings
+scalacOptions := Seq("-deprecation", "-language:postfixOps", "-Ybackend:GenBCode", "-Ydelambdafy:method", "-target:jvm-1.8")
+javacOptions in compile ++= Seq("-target", "8", "-source", "8")
+javaOptions in Jetty += "-Dlogback.configurationFile=/logback-dev.xml"
+testOptions in Test += Tests.Argument(TestFrameworks.Specs2, "junitxml", "console")
+javaOptions in Test += "-Dgitbucket.home=target/gitbucket_home_for_test"
+testOptions in Test += Tests.Setup( () => new java.io.File("target/gitbucket_home_for_test").mkdir() )
+fork in Test := true
+packageOptions += Package.MainClass("JettyLauncher")
+
+// Assembly settings
+test in assembly := {}
+assemblyMergeStrategy in assembly := {
+  case PathList("META-INF", xs @ _*) =>
+    (xs map {_.toLowerCase}) match {
+      case ("manifest.mf" :: Nil) => MergeStrategy.discard
+      case _ => MergeStrategy.discard
+    }
+  case x => MergeStrategy.first
+}
+
+// JRebel
+jrebel.webLinks += (target in webappPrepare).value
+jrebel.enabled := System.getenv().get("JREBEL") != null
+javaOptions in Jetty ++= Option(System.getenv().get("JREBEL")).toSeq.flatMap { path =>
+  Seq("-noverify", "-XX:+UseConcMarkSweepGC", "-XX:+CMSClassUnloadingEnabled", s"-javaagent:${path}")
+}
+jrebelSettings
+
+// Create executable war file
+val executableConfig = config("executable").hide
+Keys.ivyConfigurations += executableConfig
+libraryDependencies ++= Seq(
+  "org.eclipse.jetty" % "jetty-security"     % JettyVersion % "executable",
+  "org.eclipse.jetty" % "jetty-webapp"       % JettyVersion % "executable",
+  "org.eclipse.jetty" % "jetty-continuation" % JettyVersion % "executable",
+  "org.eclipse.jetty" % "jetty-server"       % JettyVersion % "executable",
+  "org.eclipse.jetty" % "jetty-xml"          % JettyVersion % "executable",
+  "org.eclipse.jetty" % "jetty-http"         % JettyVersion % "executable",
+  "org.eclipse.jetty" % "jetty-servlet"      % JettyVersion % "executable",
+  "org.eclipse.jetty" % "jetty-io"           % JettyVersion % "executable",
+  "org.eclipse.jetty" % "jetty-util"         % JettyVersion % "executable"
+)
+
+val executableKey = TaskKey[File]("executable")
+executableKey := {
+  import org.apache.ivy.util.ChecksumHelper
+  import java.util.jar.{ Manifest => JarManifest }
+  import java.util.jar.Attributes.{ Name => AttrName }
+
+  val workDir   = Keys.target.value / "executable"
+  val warName   = Keys.name.value + ".war"
+
+  val log       = streams.value.log
+  log info s"building executable webapp in ${workDir}"
+
+  // initialize temp directory
+  val temp  = workDir / "webapp"
+  IO delete temp
+
+  // include jetty classes
+  val jettyJars = Keys.update.value select configurationFilter(name = executableConfig.name)
+  jettyJars foreach { jar =>
+    IO unzip (jar, temp, (name:String) =>
+      (name startsWith "javax/") ||
+      (name startsWith "org/")
+    )
+  }
+
+  // include original war file
+  val warFile   = (Keys.`package`).value
+  IO unzip (warFile, temp)
+
+  // include launcher classes
+  val classDir      = (Keys.classDirectory in Compile).value
+  val launchClasses = Seq("JettyLauncher.class" /*, "HttpsSupportConnector.class" */)
+  launchClasses foreach { name =>
+    IO copyFile (classDir / name, temp / name)
+  }
+
+  // zip it up
+  IO delete (temp / "META-INF" / "MANIFEST.MF")
+  val contentMappings   = (temp.*** --- PathFinder(temp)).get pair relativeTo(temp)
+  val manifest          = new JarManifest
+  manifest.getMainAttributes put (AttrName.MANIFEST_VERSION,    "1.0")
+  manifest.getMainAttributes put (AttrName.MAIN_CLASS,          "JettyLauncher")
+  val outputFile    = workDir / warName
+  IO jar (contentMappings, outputFile, manifest)
+
+  // generate checksums
+  Seq(
+    "md5"    -> "MD5",
+    "sha1"   -> "SHA-1",
+    "sha256" -> "SHA-256"
+  )
+  .foreach { case (extension, algorithm) =>
+    val checksumFile = workDir / (warName + "." + extension)
+    Checksums generate (outputFile, checksumFile, algorithm)
+  }
+
+  // done
+  log info s"built executable webapp ${outputFile}"
+  outputFile
+}
+/*
+Keys.artifact in (Compile, executableKey) ~= {
+    _ copy (`type` = "war", extension = "war"))
+}
+addArtifact(Keys.artifact in (Compile, executableKey), executableKey)
+*/

doc/auto_update.md

@@ -8,7 +8,7 @@ To release a new version of GitBucket, add the version definition to the [gitbuc
 object AutoUpdate {
   ...
   /**
-   * The history of versions. A head of this sequence is the current BitBucket version.
+   * The history of versions. A head of this sequence is the current GitBucket version.
    */
   val versions = Seq(
       Version(1, 0)
@@ -20,7 +20,7 @@ Next, add a SQL file which updates database schema into [/src/main/resources/upd
 
 GitBucket stores the current version to ```GITBUCKET_HOME/version``` and checks it at start-up. If the stored version differs from the actual version, it executes differences of SQL files between the stored version and the actual version. And ```GITBUCKET_HOME/version``` is updated by the actual version.
 
-We can also add any Scala code for upgrade GitBucket which modifies ｒesources other than database. Override ```Version.update``` like below:
+We can also add any Scala code for upgrade GitBucket which modifies resources other than database. Override ```Version.update``` like below:
 
 ```scala
 val versions = Seq(

doc/directory.md

@@ -8,10 +8,10 @@ This directory has following structure:
 * /HOME/gitbucket
   * /repositories 
     * /USER_NAME
-      * / REPO_NAME.git (substance of repository. GitServlet sees this directory)
-      * / REPO_NAME
+      * /REPO_NAME.git (substance of repository. GitServlet sees this directory)
+      * /REPO_NAME
         * /issues (files which are attached to issue)
-      * / REPO_NAME.wiki.git (wiki repository)
+      * /REPO_NAME.wiki.git (wiki repository)
   * /data
     * /USER_NAME
       * /files

doc/how_to_run.md

@@ -27,7 +27,16 @@ $ sbt package
 
 To build executable war file, run
 
-*  Windows: Not available
-*  Linux: `./release/make-release-war.sh`
+```
+$ sbt executable
+```
 
-at the top of the source tree. It generates executable `gitbucket.war` into `target/scala-2.11`. We release this war file as release artifact.
+at the top of the source tree. It generates executable `gitbucket.war` into `target/executable`. We release this war file as release artifact.
+
+Run tests spec
+---------
+To run the full serie of tests, run the following command:
+
+```
+sbt test
+```

doc/jrebel.md

@@ -0,0 +1,148 @@
+JRebel integration (optional)
+=============================
+
+[JRebel](http://zeroturnaround.com/software/jrebel/) is a JVM plugin that makes developing web apps much faster.
+JRebel is generally able to eliminate the need for the following slow "app restart" in sbt following a code change:
+
+```
+> jetty:start
+```
+
+While JRebel is not open source, it does reload your code faster than the `~;copy-resources;aux-compile` way of doing things using `sbt`.
+
+It's only used during development, and doesn't change your deployed app in any way.
+
+JRebel used to be free for Scala developers, but that changed recently, and now there's a cost associated with usage for Scala. There are trial plans and free non-commercial licenses available if you just want to try it out.
+
+----
+
+## 1. Get a JRebel license
+
+Sign up for a [usage plan](https://my.jrebel.com/). You will need to create an account.
+
+## 2. Download JRebel
+
+Download the most recent ["nosetup" JRebel zip](http://zeroturnaround.com/software/jrebel/download/prev-releases/).
+Next, unzip the downloaded file.
+
+## 3. Activate
+
+Follow the [instructions on the JRebel website](http://zeroturnaround.com/software/jrebel/download/prev-releases/) to activate your downloaded JRebel.
+
+You can use the default settings for all the configurations.
+
+You don't need to integrate with your IDE, since we're using sbt to do the servlet deployment.
+
+## 4. Tell jvm where JRebel is
+
+Fortunately, the gitbucket project is already set up to use JRebel.
+You only need to tell jvm where to find the jrebel jar.
+
+To do so, edit your shell resource file (usually `~/.bash_profile` on Mac, and `~/.bashrc` on Linux), and add the following line:
+
+```bash
+export JREBEL=/path/to/jrebel/jrebel.jar
+```
+
+For example, if you unzipped your JRebel download in your home directory, you whould use:
+
+```bash
+export JREBEL=~/jrebel/jrebel.jar
+```
+
+Now reload your shell:
+
+```
+$ source ~/.bash_profile # on Mac
+$ source ~/.bashrc       # on Linux
+```
+
+## 5. See it in action!
+
+Now you're ready to use JRebel with the gitbucket.
+When you run sbt as normal, you will see a long message from JRebel, indicating it has loaded.
+Here's an abbreviated version of what you will see:
+
+```
+$ ./sbt
+[info] Loading project definition from /git/gitbucket/project
+[info] Set current project to gitbucket (in build file:/git/gitbucket/)
+>
+```
+
+You will start the servlet container slightly differently now that you're using sbt.
+
+```
+> jetty:start
+:
+[info] starting server ...
+[success] Total time: 3 s, completed Jan 3, 2016 9:47:55 PM
+2016-01-03 21:47:57 JRebel:
+2016-01-03 21:47:57 JRebel: A newer version '6.3.1' is available for download
+2016-01-03 21:47:57 JRebel: from http://zeroturnaround.com/software/jrebel/download/
+2016-01-03 21:47:57 JRebel:
+2016-01-03 21:47:58 JRebel: Contacting myJRebel server ..
+2016-01-03 21:47:59 JRebel: Directory '/git/gitbucket/target/scala-2.11/classes' will be monitored for changes.
+2016-01-03 21:47:59 JRebel: Directory '/git/gitbucket/target/scala-2.11/test-classes' will be monitored for changes.
+2016-01-03 21:47:59 JRebel: Directory '/git/gitbucket/target/webapp' will be monitored for changes.
+2016-01-03 21:48:00 JRebel:
+2016-01-03 21:48:00 JRebel:  #############################################################
+2016-01-03 21:48:00 JRebel:
+2016-01-03 21:48:00 JRebel:  JRebel Legacy Agent 6.2.5 (201509291538)
+2016-01-03 21:48:00 JRebel:  (c) Copyright ZeroTurnaround AS, Estonia, Tartu.
+2016-01-03 21:48:00 JRebel:
+2016-01-03 21:48:00 JRebel:  Over the last 30 days JRebel prevented
+2016-01-03 21:48:00 JRebel:  at least 182 redeploys/restarts saving you about 7.4 hours.
+2016-01-03 21:48:00 JRebel:
+2016-01-03 21:48:00 JRebel:  Over the last 324 days JRebel prevented
+2016-01-03 21:48:00 JRebel:  at least 1538 redeploys/restarts saving you about 62.4 hours.
+2016-01-03 21:48:00 JRebel:
+2016-01-03 21:48:00 JRebel:  Licensed to nazo king (using myJRebel).
+2016-01-03 21:48:00 JRebel:
+2016-01-03 21:48:00 JRebel:
+2016-01-03 21:48:00 JRebel:  #############################################################
+2016-01-03 21:48:00 JRebel:
+:
+
+> ~ copy-resources
+[success] Total time: 0 s, completed Jan 3, 2016 9:13:54 PM
+1. Waiting for source changes... (press enter to interrupt)
+```
+
+Finally, change your code.
+For example, you can change the title on `src/main/twirl/gitbucket/core/main.scala.html` like this:
+
+```html
+:
+  <a class="navbar-brand" href="@path/">
+    <img src="@assets/common/images/gitbucket.png" style="width: 24px; height: 24px;"/>GitBucket
+    @defining(AutoUpdate.getCurrentVersion){ version =>
+      <span class="header-version">@version.majorVersion.@version.minorVersion</span>
+    }
+    change code !!!!!!!!!!!!!!!!
+  </a>
+:
+```
+
+If JRebel is doing is correctly installed you will see a notice for you:
+
+```
+1. Waiting for source changes... (press enter to interrupt)
+2016-01-03 21:48:42 JRebel: Reloading class 'gitbucket.core.html.main$'.
+[info] Wrote rebel.xml to /git/gitbucket/target/scala-2.11/resource_managed/main/rebel.xml
+[info] Compiling 1 Scala source to /git/gitbucket/target/scala-2.11/classes...
+[success] Total time: 3 s, completed Jan 3, 2016 9:48:55 PM
+2. Waiting for source changes... (press enter to interrupt)
+```
+
+And you reload browser, JRebel give notice of that it has reloaded classes:
+
+```
+[success] Total time: 3 s, completed Jan 3, 2016 9:48:55 PM
+2. Waiting for source changes... (press enter to interrupt)
+2016-01-03 21:49:13 JRebel: Reloading class 'gitbucket.core.html.main$'.
+```
+
+## 6. Limitations
+
+JRebel is nearly always able to eliminate the need to explicitly reload your container after a code change. However, if you change any of your routes patterns, there is nothing JRebel can do, you will have to run `jetty:start`.

doc/readme.md

@@ -9,3 +9,4 @@ Developer's Guide
  * [Notification Email](notification.md)
  * [Automatic Schema Updating](auto_update.md)
  * [Release Operation](release.md)
+ * [JRebel integration (optional)](jrebel.md)

doc/release.md

@@ -6,15 +6,14 @@ Update version number
 
 Note to update version number in files below:
 
-### project/build.scala
+### build.sbt
 
 ```scala
-object MyBuild extends Build {
-  val Organization = "gitbucket"
-  val Name = "gitbucket"
-  val Version = "3.3.0" // <---- update version!!
-  val ScalaVersion = "2.11.6"
-  val ScalatraVersion = "2.3.1"
+val Organization = "gitbucket"
+val Name = "gitbucket"
+val GitBucketVersion = "3.12.0" // <---- update version!!
+val ScalatraVersion = "2.4.0"
+val JettyVersion = "9.3.6.v20151106"
 ```
 
 ### src/main/scala/gitbucket/core/servlet/AutoUpdate.scala
@@ -23,11 +22,11 @@ object MyBuild extends Build {
 object AutoUpdate {
 
   /**
-   * The history of versions. A head of this sequence is the current BitBucket version.
+   * The history of versions. A head of this sequence is the current GitBucket version.
    */
   val versions = Seq(
-    new Version(3, 3), // <---- add this line!!
-    new Version(3, 2),
+    new Version(3, 12), // <---- add this line!!
+    new Version(3, 11),
 ```
 
 Generate release files
@@ -37,11 +36,10 @@ Note: Release operation requires [Ant](http://ant.apache.org/) and [Maven](https
 
 ### Make release war file
 
-Run `release/make-release-war.sh`. The release war file is generated into `target/scala-2.11/gitbucket.war`.
+Run `sbt executable`. The release war file and fingerprint are generated into `target/executable/gitbucket.war`.
 
 ```bash
-$ cd release
-$ ./make-release-war.sh
+$sbt executable
 ```
 
 ### Deploy assembly jar file

embed-jetty/update.sh

@@ -1,11 +0,0 @@
-#!/bin/bash
-version=$1
-output_dir=`dirname $0`
-git rm -f ${output_dir}/jetty-*.jar
-for name in 'io' 'servlet' 'xml' 'continuation' 'security' 'util' 'http' 'server' 'webapp'
-do
-  jar_filename="jetty-${name}-${version}.jar"
-  wget "http://repo1.maven.org/maven2/org/eclipse/jetty/jetty-${name}/${version}/${jar_filename}" -O ${output_dir}/${jar_filename}
-done
-git add ${output_dir}/*.jar
-git commit

project/Checksums.scala

@@ -0,0 +1,34 @@
+import java.security.MessageDigest;
+import scala.annotation._
+import sbt._
+import sbt.Using._
+
+object Checksums {
+  private val bufferSize = 2048
+
+  def generate(source:File, target:File, algorithm:String):Unit =
+      IO write (target, compute(source, algorithm))
+
+  def compute(file:File, algorithm:String):String =
+      hex(raw(file, algorithm))
+
+  def raw(file:File, algorithm:String):Array[Byte]    =
+      (Using fileInputStream file) { is =>
+        val md  = MessageDigest getInstance algorithm
+        val buf = new Array[Byte](bufferSize)
+        md.reset()
+        @tailrec
+        def loop() {
+          val len = is read buf
+          if (len != -1) {
+            md update (buf, 0, len)
+            loop()
+          }
+        }
+        loop()
+        md.digest()
+      }
+
+  def hex(bytes:Array[Byte]):String =
+      bytes map { it => "%02x" format (it.toInt & 0xff) } mkString ""
+}

project/build.properties

@@ -1 +1 @@
-sbt.version=0.13.8
+sbt.version=0.13.9

project/build.scala

@@ -1,80 +0,0 @@
-import com.earldouglas.xwp.JettyPlugin
-import play.twirl.sbt.SbtTwirl
-import sbt.Keys._
-import sbt._
-import sbtassembly.AssemblyKeys._
-import sbtassembly._
-import JettyPlugin.autoImport._
-
-object MyBuild extends Build {
-  val Organization = "gitbucket"
-  val Name = "gitbucket"
-  val Version = "3.9.1"
-  val ScalaVersion = "2.11.6"
-  val ScalatraVersion = "2.3.1"
-
-  lazy val project = Project (
-    "gitbucket",
-    file(".")
-  )
-//  .settings(ScalatraPlugin.scalatraWithJRebel: _*)
-  .settings(
-    test in assembly := {},
-    assemblyMergeStrategy in assembly := {
-      case PathList("META-INF", xs @ _*) =>
-        (xs map {_.toLowerCase}) match {
-          case ("manifest.mf" :: Nil) => MergeStrategy.discard
-          case _ => MergeStrategy.discard
-      }
-      case x => MergeStrategy.first
-    }
-  )
-  .settings(
-    sourcesInBase := false,
-    organization := Organization,
-    name := Name,
-    version := Version,
-    scalaVersion := ScalaVersion,
-    resolvers ++= Seq(
-      Classpaths.typesafeReleases,
-      "amateras-repo" at "http://amateras.sourceforge.jp/mvn/",
-      "amateras-snapshot-repo" at "http://amateras.sourceforge.jp/mvn-snapshot/"
-    ),
-    scalacOptions := Seq("-deprecation", "-language:postfixOps"),
-    libraryDependencies ++= Seq(
-      "org.eclipse.jgit" % "org.eclipse.jgit.http.server" % "3.4.2.201412180340-r",
-      "org.eclipse.jgit" % "org.eclipse.jgit.archive" % "3.4.2.201412180340-r",
-      "org.scalatra" %% "scalatra" % ScalatraVersion,
-      "org.scalatra" %% "scalatra-specs2" % ScalatraVersion % "test",
-      "org.scalatra" %% "scalatra-json" % ScalatraVersion,
-      "org.json4s" %% "json4s-jackson" % "3.2.11",
-      "jp.sf.amateras" %% "scalatra-forms" % "0.2.0",
-      "commons-io" % "commons-io" % "2.4",
-      "io.github.gitbucket" % "markedj" % "1.0.6-SNAPSHOT",
-      "org.apache.commons" % "commons-compress" % "1.9",
-      "org.apache.commons" % "commons-email" % "1.3.3",
-      "org.apache.httpcomponents" % "httpclient" % "4.3.6",
-      "org.apache.sshd" % "apache-sshd" % "1.0.0",
-      "org.apache.tika" % "tika-core" % "1.10",
-      "com.typesafe.slick" %% "slick" % "2.1.0",
-      "com.novell.ldap" % "jldap" % "2009-10-07",
-      "com.h2database" % "h2" % "1.4.180",
-      "ch.qos.logback" % "logback-classic" % "1.1.1",
-      "org.eclipse.jetty" % "jetty-webapp" % "8.1.16.v20140903" % "provided",
-      "javax.servlet" % "javax.servlet-api" % "3.0.1" % "provided",
-      "junit" % "junit" % "4.12" % "test",
-      "com.mchange" % "c3p0" % "0.9.5.2",
-      "com.typesafe" % "config" % "1.2.1",
-      "com.typesafe.akka" %% "akka-actor" % "2.3.10",
-      "com.enragedginger" %% "akka-quartz-scheduler" % "1.3.0-akka-2.3.x"  exclude("c3p0","c3p0")
-    ),
-    play.twirl.sbt.Import.TwirlKeys.templateImports += "gitbucket.core._",
-    javacOptions in compile ++= Seq("-target", "7", "-source", "7"),
-    javaOptions in Jetty += "-Dlogback.configurationFile=/logback-dev.xml",
-    testOptions in Test += Tests.Argument(TestFrameworks.Specs2, "junitxml", "console"),
-    javaOptions in Test += "-Dgitbucket.home=target/gitbucket_home_for_test",
-    testOptions in Test += Tests.Setup( () => new java.io.File("target/gitbucket_home_for_test").mkdir() ),
-    fork in Test := true,
-    packageOptions += Package.MainClass("JettyLauncher")
-  ).enablePlugins(SbtTwirl, JettyPlugin)
-}

project/plugins.sbt

@@ -2,4 +2,5 @@ scalacOptions ++= Seq("-unchecked", "-deprecation", "-feature")
 
 addSbtPlugin("com.typesafe.sbt" % "sbt-twirl"       % "1.0.4")
 addSbtPlugin("com.eed3si9n"     % "sbt-assembly"    % "0.12.0")
-addSbtPlugin("com.earldouglas"  % "xsbt-web-plugin" % "2.1.0")
+addSbtPlugin("com.earldouglas"  % "xsbt-web-plugin" % "2.1.0")
+addSbtPlugin("fi.gekkio.sbtplugins" % "sbt-jrebel-plugin" % "0.10.0")

release/build.xml

@@ -1,67 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<project name="gitbucket" default="all" basedir="..">
-
-  <property environment="env"/>
-  <property name="target.dir" value="target"/>
-  <property name="embed.classes.dir" value="${target.dir}/embed-classes"/>
-  <property name="jetty.dir" value="embed-jetty"/>
-  <property name="scala.version" value="2.11"/>
-  <property name="gitbucket.version" value="${env.GITBUCKET_VERSION}"/>
-  <property name="jetty.version" value="8.1.16.v20140903"/>
-  <property name="servlet.version" value="3.0.0.v201112011016"/>
-
-  <condition property="sbt.exec" value="sbt.bat" else="sbt.sh">
-    <os family="windows" />
-  </condition>
-
-  <target name="clean">
-    <delete dir="${embed.classes.dir}"/>
-    <delete file="${target.dir}/scala-${scala.version}/gitbucket.war"/>
-  </target>
-
-  <target name="war" depends="clean">
-    <exec executable="${sbt.exec}" resolveexecutable="true" failonerror="true">
-      <arg line="clean compile test package" />
-    </exec>
-  </target>
-
-  <target name="embed" depends="war">
-    <mkdir dir="${embed.classes.dir}"/>
-
-    <unzip dest="${embed.classes.dir}" src="${jetty.dir}/javax.servlet-${servlet.version}.jar" />
-    <unzip dest="${embed.classes.dir}" src="${jetty.dir}/jetty-continuation-${jetty.version}.jar" />
-    <unzip dest="${embed.classes.dir}" src="${jetty.dir}/jetty-http-${jetty.version}.jar" />
-    <unzip dest="${embed.classes.dir}" src="${jetty.dir}/jetty-io-${jetty.version}.jar" />
-    <unzip dest="${embed.classes.dir}" src="${jetty.dir}/jetty-security-${jetty.version}.jar" />
-    <unzip dest="${embed.classes.dir}" src="${jetty.dir}/jetty-server-${jetty.version}.jar" />
-    <unzip dest="${embed.classes.dir}" src="${jetty.dir}/jetty-servlet-${jetty.version}.jar" />
-    <unzip dest="${embed.classes.dir}" src="${jetty.dir}/jetty-util-${jetty.version}.jar" />
-    <unzip dest="${embed.classes.dir}" src="${jetty.dir}/jetty-webapp-${jetty.version}.jar" />
-    <unzip dest="${embed.classes.dir}" src="${jetty.dir}/jetty-xml-${jetty.version}.jar" />
-
-    <zip destfile="${target.dir}/scala-${scala.version}/gitbucket_${scala.version}-${gitbucket.version}.war"
-         basedir="${embed.classes.dir}"
-         update = "true"
-         includes="javax/**,org/**"/>
-
-    <zip destfile="${target.dir}/scala-${scala.version}/gitbucket_${scala.version}-${gitbucket.version}.war"
-         basedir="${target.dir}/scala-${scala.version}/classes"
-         update = "true"
-         includes="JettyLauncher.class,HttpsSupportConnector.class"/>
-  </target>
-
-  <target name="rename" depends="embed">
-    <move file="${target.dir}/scala-${scala.version}/gitbucket_${scala.version}-${gitbucket.version}.war"
-            tofile="${target.dir}/scala-${scala.version}/gitbucket.war"/>
-  </target>
-
-  <target name="checksum" depends="rename">
-    <checksum file="${target.dir}/scala-${scala.version}/gitbucket.war" algorithm="MD5" format="MD5SUM" forceOverwrite="yes" fileext=".md5"/>
-    <checksum file="${target.dir}/scala-${scala.version}/gitbucket.war" algorithm="SHA" format="MD5SUM" forceOverwrite="yes" fileext=".sha1"/>
-  </target>
-
-  <target name="all" depends="checksum">
-  </target>
-
-
-</project>

release/deploy-assembly-jar.sh

@@ -5,6 +5,15 @@ cd ../
 ./sbt.sh clean assembly
 
 cd release
+
+if [[ "$GITBUCKET_VERSION" =~ -SNAPSHOT$ ]]; then
+  MVN_DEPLOY_PATH=mvn-snapshot
+else
+  MVN_DEPLOY_PATH=mvn
+fi
+
+echo $MVN_DEPLOY_PATH
+
 mvn deploy:deploy-file \
   -DgroupId=gitbucket\
   -DartifactId=gitbucket-assembly\
@@ -12,4 +21,4 @@ mvn deploy:deploy-file \
   -Dpackaging=jar\
   -Dfile=../target/scala-2.11/gitbucket-assembly-$GITBUCKET_VERSION.jar\
   -DrepositoryId=sourceforge.jp\
-  -Durl=scp://shell.sourceforge.jp/home/groups/a/am/amateras/htdocs/mvn/
+  -Durl=scp://shell.sourceforge.jp/home/groups/a/am/amateras/htdocs/$MVN_DEPLOY_PATH/

release/env.sh

@@ -1,3 +1,3 @@
 #!/bin/sh
-export GITBUCKET_VERSION=`cat ../project/build.scala | grep 'val Version' | cut -d \" -f 2`
+export GITBUCKET_VERSION=`cat ../build.sbt | grep 'val GitBucketVersion' | cut -d \" -f 2`
 echo "GITBUCKET_VERSION: $GITBUCKET_VERSION"

release/make-release-war.sh

@@ -1,15 +0,0 @@
-#!/bin/sh
-D="$(dirname "$0")"
-D="$(cd "${D}"; pwd)"
-DD="$(dirname "${D}")"
-(
-  for f in "${D}/env.sh" "${D}/build.xml"; do
-    if [ ! -s "${f}" ]; then
-      echo >&2 "$0: Unable to access file '${f}'"
-      exit 1
-    fi
-  done
-  . "${D}/env.sh"
-  cd "${DD}"
-  ant -f "${D}/build.xml" all
-)

release/pom.xml

@@ -10,7 +10,7 @@
             <extension>
                 <groupId>org.apache.maven.wagon</groupId>
                 <artifactId>wagon-ssh</artifactId>
-                <version>1.0-beta-6</version>
+                <version>2.10</version>
             </extension>
         </extensions>
     </build>

sbt.bat

@@ -1,2 +1,2 @@
 set SCRIPT_DIR=%~dp0
-java %JAVA_OPTS% -Dsbt.log.noformat=true -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256m -Xmx512M -Xss2M -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -jar "%SCRIPT_DIR%\sbt-launch-0.13.8.jar" %*
+java %JAVA_OPTS% -Dsbt.log.noformat=true -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256m -Xmx512M -Xss2M -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -jar "%SCRIPT_DIR%\sbt-launch-0.13.9.jar" %*

sbt.sh

@@ -1,2 +1,2 @@
 #!/bin/sh
-java $JAVA_OPTS -Dsbt.log.noformat=true -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256m -Xmx512M -Xss2M -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -jar `dirname $0`/sbt-launch-0.13.8.jar "$@"
+java $JAVA_OPTS -Dsbt.log.noformat=true -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256m -Xmx512M -Xss2M -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -jar `dirname $0`/sbt-launch-0.13.9.jar "$@"

src/main/java/JettyLauncher.java

@@ -1,5 +1,4 @@
 import org.eclipse.jetty.server.Server;
-import org.eclipse.jetty.server.nio.SelectChannelConnector;
 import org.eclipse.jetty.webapp.WebAppContext;
 
 import java.io.File;
@@ -30,16 +29,16 @@ public class JettyLauncher {
             }
         }
 
-        Server server = new Server();
+        Server server = new Server(port);
 
-        SelectChannelConnector connector = new SelectChannelConnector();
-        if(host != null) {
-            connector.setHost(host);
-        }
-        connector.setMaxIdleTime(1000 * 60 * 60);
-        connector.setSoLingerTime(-1);
-        connector.setPort(port);
-        server.addConnector(connector);
+//        SelectChannelConnector connector = new SelectChannelConnector();
+//        if(host != null) {
+//            connector.setHost(host);
+//        }
+//        connector.setMaxIdleTime(1000 * 60 * 60);
+//        connector.setSoLingerTime(-1);
+//        connector.setPort(port);
+//        server.addConnector(connector);
 
         WebAppContext context = new WebAppContext();
 

src/main/resources/logback.xml

@@ -6,12 +6,14 @@
     </encoder>
   </appender>
 
+  <!--
   <appender name="FILE" class="ch.qos.logback.core.FileAppender">
     <file>gitbucket.log</file>
     <encoder>
       <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
     </encoder>
   </appender>
+  -->
 
   <root level="INFO">
     <appender-ref ref="STDOUT" />

src/main/resources/update/3_11.sql

@@ -0,0 +1,25 @@
+DROP TABLE IF EXISTS PROTECTED_BRANCH;
+
+CREATE TABLE PROTECTED_BRANCH(
+    USER_NAME VARCHAR(100) NOT NULL,
+    REPOSITORY_NAME VARCHAR(100) NOT NULL,
+    BRANCH VARCHAR(100) NOT NULL,
+    STATUS_CHECK_ADMIN BOOLEAN NOT NULL DEFAULT false
+);
+
+ALTER TABLE PROTECTED_BRANCH ADD CONSTRAINT IDX_PROTECTED_BRANCH_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, BRANCH);
+ALTER TABLE PROTECTED_BRANCH ADD CONSTRAINT IDX_PROTECTED_BRANCH_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME) REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME)
+  ON DELETE CASCADE ON UPDATE CASCADE;
+
+
+DROP TABLE IF EXISTS PROTECTED_BRANCH_REQUIRE_CONTEXT;
+CREATE TABLE PROTECTED_BRANCH_REQUIRE_CONTEXT(
+    USER_NAME VARCHAR(100) NOT NULL,
+    REPOSITORY_NAME VARCHAR(100) NOT NULL,
+    BRANCH VARCHAR(100) NOT NULL,
+    CONTEXT VARCHAR(255) NOT NULL
+);
+
+ALTER TABLE PROTECTED_BRANCH_REQUIRE_CONTEXT ADD CONSTRAINT IDX_PROTECTED_BRANCH_REQUIRE_CONTEXT_PK PRIMARY KEY (USER_NAME, REPOSITORY_NAME, BRANCH, CONTEXT);
+ALTER TABLE PROTECTED_BRANCH_REQUIRE_CONTEXT ADD CONSTRAINT IDX_PROTECTED_BRANCH_REQUIRE_CONTEXT_FK0 FOREIGN KEY (USER_NAME, REPOSITORY_NAME, BRANCH) REFERENCES PROTECTED_BRANCH (USER_NAME, REPOSITORY_NAME, BRANCH)
+  ON DELETE CASCADE ON UPDATE CASCADE;

src/main/resources/update/3_13.sql

@@ -0,0 +1 @@
+ALTER TABLE WEB_HOOK ADD COLUMN TOKEN VARCHAR(100);

src/main/resources/update/3_14.sql

@@ -0,0 +1,3 @@
+ALTER TABLE WEB_HOOK ADD COLUMN CTYPE VARCHAR(10);
+
+UPDATE WEB_HOOK SET CTYPE = 'form';

src/main/scala/ScalatraBootstrap.scala

@@ -27,12 +27,10 @@ class ScalatraBootstrap extends LifeCycle {
     }
 
     context.mount(new IndexController, "/")
-    context.mount(new SearchController, "/")
+    context.mount(new ApiController, "/api/v3")
     context.mount(new FileUploadController, "/upload")
+    context.mount(new SystemSettingsController, "/admin")
     context.mount(new DashboardController, "/*")
-    context.mount(new UserManagementController, "/*")
-    context.mount(new SystemSettingsController, "/*")
-    context.mount(new PluginsController, "/*")
     context.mount(new AccountController, "/*")
     context.mount(new RepositoryViewerController, "/*")
     context.mount(new WikiController, "/*")

src/main/scala/gitbucket/core/api/ApiBranch.scala

@@ -0,0 +1,16 @@
+package gitbucket.core.api
+
+import gitbucket.core.util.RepositoryName
+
+/**
+ * https://developer.github.com/v3/repos/#get-branch
+ * https://developer.github.com/v3/repos/#enabling-and-disabling-branch-protection
+ */
+case class ApiBranch(
+  name: String,
+  // commit: ApiBranchCommit,
+  protection: ApiBranchProtection)(repositoryName:RepositoryName) extends FieldSerializable {
+  def _links = Map(
+   "self" -> ApiPath(s"/api/v3/repos/${repositoryName.fullName}/branches/${name}"),
+   "html" -> ApiPath(s"/${repositoryName.fullName}/tree/${name}"))
+}

src/main/scala/gitbucket/core/api/ApiBranchProtection.scala

@@ -0,0 +1,47 @@
+package gitbucket.core.api
+
+import gitbucket.core.service.ProtectedBranchService
+import org.json4s._
+
+/** https://developer.github.com/v3/repos/#enabling-and-disabling-branch-protection */
+case class ApiBranchProtection(enabled: Boolean, required_status_checks: Option[ApiBranchProtection.Status]){
+  def status: ApiBranchProtection.Status = required_status_checks.getOrElse(ApiBranchProtection.statusNone)
+}
+
+object ApiBranchProtection{
+  /** form for enabling-and-disabling-branch-protection */
+  case class EnablingAndDisabling(protection: ApiBranchProtection)
+
+  def apply(info: ProtectedBranchService.ProtectedBranchInfo): ApiBranchProtection = ApiBranchProtection(
+    enabled = info.enabled,
+    required_status_checks = Some(Status(EnforcementLevel(info.enabled, info.includeAdministrators), info.contexts)))
+  val statusNone = Status(Off, Seq.empty)
+  case class Status(enforcement_level: EnforcementLevel, contexts: Seq[String])
+  sealed class EnforcementLevel(val name: String)
+  case object Off extends EnforcementLevel("off")
+  case object NonAdmins extends EnforcementLevel("non_admins")
+  case object Everyone extends EnforcementLevel("everyone")
+  object EnforcementLevel {
+    def apply(enabled: Boolean, includeAdministrators: Boolean): EnforcementLevel = if(enabled){
+      if(includeAdministrators){
+        Everyone
+      }else{
+        NonAdmins
+      }
+    }else{
+      Off
+    }
+  }
+
+  implicit val enforcementLevelSerializer = new CustomSerializer[EnforcementLevel](format => (
+   {
+     case JString("off") => Off
+     case JString("non_admins") => NonAdmins
+     case JString("everyone") => Everyone
+   },
+   {
+     case x: EnforcementLevel => JString(x.name)
+   }
+ ))
+}
+

src/main/scala/gitbucket/core/api/ApiIssue.scala

@@ -20,6 +20,16 @@ case class ApiIssue(
   body: String)(repositoryName: RepositoryName, isPullRequest: Boolean){
   val comments_url = ApiPath(s"/api/v3/repos/${repositoryName.fullName}/issues/${number}/comments")
   val html_url = ApiPath(s"/${repositoryName.fullName}/${if(isPullRequest){ "pull" }else{ "issues" }}/${number}")
+  val pull_request = if (isPullRequest) {
+    Some(Map(
+      "url" -> ApiPath(s"/api/v3/repos/${repositoryName.fullName}/pulls/${number}"),
+      "html_url" -> ApiPath(s"/${repositoryName.fullName}/pull/${number}")
+      // "diff_url" -> ApiPath(s"/${repositoryName.fullName}/pull/${number}.diff"),
+      // "patch_url" -> ApiPath(s"/${repositoryName.fullName}/pull/${number}.patch")
+    ))
+  } else {
+    None
+  }
 }
 
 object ApiIssue{

src/main/scala/gitbucket/core/api/ApiLabel.scala

@@ -0,0 +1,21 @@
+package gitbucket.core.api
+
+import gitbucket.core.model.Label
+import gitbucket.core.util.RepositoryName
+
+/**
+  * https://developer.github.com/v3/issues/labels/
+  */
+case class ApiLabel(
+  name: String,
+  color: String)(repositoryName: RepositoryName){
+  var url = ApiPath(s"/api/v3/repos/${repositoryName.fullName}/labels/${name}")
+}
+
+object ApiLabel{
+  def apply(label:Label, repositoryName: RepositoryName): ApiLabel =
+    ApiLabel(
+      name = label.labelName,
+      color = label.color
+    )(repositoryName)
+}

src/main/scala/gitbucket/core/api/CreateALabel.scala

@@ -0,0 +1,18 @@
+package gitbucket.core.api
+
+/**
+  * https://developer.github.com/v3/issues/labels/#create-a-label
+  * api form
+  */
+case class CreateALabel(
+    name: String,
+    color: String
+) {
+  def isValid: Boolean = {
+    name.length<=100 &&
+      !name.startsWith("_") &&
+      !name.startsWith("-") &&
+      color.length==6 &&
+      color.matches("[a-fA-F0-9+_.]+")
+  }
+}

src/main/scala/gitbucket/core/api/JsonFormat.scala

@@ -30,7 +30,9 @@ object JsonFormat {
     FieldSerializer[ApiCombinedCommitStatus]() +
     FieldSerializer[ApiPullRequest.Commit]() +
     FieldSerializer[ApiIssue]() +
-    FieldSerializer[ApiComment]()
+    FieldSerializer[ApiComment]() +
+    FieldSerializer[ApiLabel]() +
+    ApiBranchProtection.enforcementLevelSerializer
 
   def apiPathSerializer(c: Context) = new CustomSerializer[ApiPath](format =>
     (

src/main/scala/gitbucket/core/controller/AccountController.scala

@@ -1,7 +1,6 @@
 package gitbucket.core.controller
 
 import gitbucket.core.account.html
-import gitbucket.core.api._
 import gitbucket.core.helper
 import gitbucket.core.model.GroupMember
 import gitbucket.core.service._
@@ -12,24 +11,21 @@ import gitbucket.core.util.Implicits._
 import gitbucket.core.util.StringUtil._
 import gitbucket.core.util._
 
-import jp.sf.amateras.scalatra.forms._
+import io.github.gitbucket.scalatra.forms._
 import org.apache.commons.io.FileUtils
-import org.eclipse.jgit.api.Git
-import org.eclipse.jgit.dircache.DirCache
-import org.eclipse.jgit.lib.{FileMode, Constants}
 import org.scalatra.i18n.Messages
 
 
 class AccountController extends AccountControllerBase
   with AccountService with RepositoryService with ActivityService with WikiService with LabelsService with SshKeyService
   with OneselfAuthenticator with UsersAuthenticator with GroupManagerAuthenticator with ReadableUsersAuthenticator
-  with AccessTokenService with WebHookService
+  with AccessTokenService with WebHookService with RepositoryCreationService
 
 
 trait AccountControllerBase extends AccountManagementControllerBase {
   self: AccountService with RepositoryService with ActivityService with WikiService with LabelsService with SshKeyService
     with OneselfAuthenticator with UsersAuthenticator with GroupManagerAuthenticator with ReadableUsersAuthenticator
-    with AccessTokenService with WebHookService =>
+    with AccessTokenService with WebHookService with RepositoryCreationService =>
 
   case class AccountNewForm(userName: String, password: String, fullName: String, mailAddress: String,
                             url: Option[String], fileId: Option[String])
@@ -133,7 +129,7 @@ trait AccountControllerBase extends AccountManagementControllerBase {
           val members = getGroupMembers(account.userName)
           gitbucket.core.account.html.repositories(account,
             if(account.isGroupAccount) Nil else getGroupsByUserName(userName),
-            getVisibleRepositories(context.loginAccount, context.baseUrl, Some(userName)),
+            getVisibleRepositories(context.loginAccount, Some(userName)),
             context.loginAccount.exists(x => members.exists { member => member.userName == x.userName && member.isManager }))
         }
       }
@@ -156,25 +152,6 @@ trait AccountControllerBase extends AccountManagementControllerBase {
     }
   }
 
-  /**
-   * https://developer.github.com/v3/users/#get-a-single-user
-   */
-  get("/api/v3/users/:userName") {
-    getAccountByUserName(params("userName")).map { account =>
-      JsonFormat(ApiUser(account))
-    } getOrElse NotFound
-  }
-
-  /**
-   * https://developer.github.com/v3/users/#get-the-authenticated-user
-   */
-  get("/api/v3/user") {
-    context.loginAccount.map { account =>
-      JsonFormat(ApiUser(account))
-    } getOrElse Unauthorized
-  }
-
-
   get("/:userName/_edit")(oneselfOnly {
     val userName = params("userName")
     getAccountByUserName(userName).map { x =>
@@ -366,8 +343,8 @@ trait AccountControllerBase extends AccountManagementControllerBase {
    */
   post("/new", newRepositoryForm)(usersOnly { form =>
     LockUtil.lock(s"${form.owner}/${form.name}"){
-      if(getRepository(form.owner, form.name, context.baseUrl).isEmpty){
-        createRepository(form.owner, form.name, form.description, form.isPrivate, form.createReadme)
+      if(getRepository(form.owner, form.name).isEmpty){
+        createRepository(context.loginAccount.get, form.owner, form.name, form.description, form.isPrivate, form.createReadme)
       }
 
       // redirect to the repository
@@ -375,54 +352,6 @@ trait AccountControllerBase extends AccountManagementControllerBase {
     }
   })
 
-  /**
-   * Create user repository
-   * https://developer.github.com/v3/repos/#create
-   */
-  post("/api/v3/user/repos")(usersOnly {
-    val owner = context.loginAccount.get.userName
-    (for {
-      data <- extractFromJsonBody[CreateARepository] if data.isValid
-    } yield {
-      LockUtil.lock(s"${owner}/${data.name}") {
-        if(getRepository(owner, data.name, context.baseUrl).isEmpty){
-          createRepository(owner, data.name, data.description, data.`private`, data.auto_init)
-          val repository = getRepository(owner, data.name, context.baseUrl).get
-          JsonFormat(ApiRepository(repository, ApiUser(getAccountByUserName(owner).get)))
-        } else {
-          ApiError(
-            "A repository with this name already exists on this account", 
-            Some("https://developer.github.com/v3/repos/#create")
-          )
-        }
-      }
-    }) getOrElse NotFound
-  })
-
-  /**
-   * Create group repository
-   * https://developer.github.com/v3/repos/#create
-   */
-  post("/api/v3/orgs/:org/repos")(managersOnly {
-    val groupName = params("org")
-    (for {
-      data <- extractFromJsonBody[CreateARepository] if data.isValid
-    } yield {
-      LockUtil.lock(s"${groupName}/${data.name}") {
-        if(getRepository(groupName, data.name, context.baseUrl).isEmpty){
-          createRepository(groupName, data.name, data.description, data.`private`, data.auto_init)
-          val repository = getRepository(groupName, data.name, context.baseUrl).get
-          JsonFormat(ApiRepository(repository, ApiUser(getAccountByUserName(groupName).get)))
-        } else {
-          ApiError(
-            "A repository with this name already exists for this group", 
-            Some("https://developer.github.com/v3/repos/#create")
-          )
-        }
-      }
-    }) getOrElse NotFound
-  })
-
   get("/:owner/:repository/fork")(readableUsersOnly { repository =>
     val loginAccount   = context.loginAccount.get
     val loginUserName  = loginAccount.userName
@@ -447,7 +376,7 @@ trait AccountControllerBase extends AccountManagementControllerBase {
     val accountName   = form.accountName
 
     LockUtil.lock(s"${accountName}/${repository.name}"){
-      if(getRepository(accountName, repository.name, baseUrl).isDefined ||
+      if(getRepository(accountName, repository.name).isDefined ||
           (accountName != loginUserName && !getGroupsByUserName(loginUserName).contains(accountName))){
         // redirect to the repository if repository already exists
         redirect(s"/${accountName}/${repository.name}")
@@ -456,7 +385,7 @@ trait AccountControllerBase extends AccountManagementControllerBase {
         val originUserName = repository.repository.originUserName.getOrElse(repository.owner)
         val originRepositoryName = repository.repository.originRepositoryName.getOrElse(repository.name)
 
-        createRepository(
+        insertRepository(
           repositoryName       = repository.name,
           userName             = accountName,
           description          = repository.repository.description,
@@ -496,68 +425,6 @@ trait AccountControllerBase extends AccountManagementControllerBase {
     }
   })
 
-  private def createRepository(owner: String, name: String, description: Option[String], isPrivate: Boolean, createReadme: Boolean) {
-    val ownerAccount  = getAccountByUserName(owner).get
-    val loginAccount  = context.loginAccount.get
-    val loginUserName = loginAccount.userName
-
-    // Insert to the database at first
-    createRepository(name, owner, description, isPrivate)
-
-    // Add collaborators for group repository
-    if(ownerAccount.isGroupAccount){
-      getGroupMembers(owner).foreach { member =>
-        addCollaborator(owner, name, member.userName)
-      }
-    }
-
-    // Insert default labels
-    insertDefaultLabels(owner, name)
-
-    // Create the actual repository
-    val gitdir = getRepositoryDir(owner, name)
-    JGitUtil.initRepository(gitdir)
-
-    if(createReadme){
-      using(Git.open(gitdir)){ git =>
-        val builder  = DirCache.newInCore.builder()
-        val inserter = git.getRepository.newObjectInserter()
-        val headId   = git.getRepository.resolve(Constants.HEAD + "^{commit}")
-        val content  = if(description.nonEmpty){
-          name + "\n" +
-          "===============\n" +
-          "\n" +
-          description.get
-        } else {
-          name + "\n" +
-          "===============\n"
-        }
-
-        builder.add(JGitUtil.createDirCacheEntry("README.md", FileMode.REGULAR_FILE,
-          inserter.insert(Constants.OBJ_BLOB, content.getBytes("UTF-8"))))
-        builder.finish()
-
-        JGitUtil.createNewCommit(git, inserter, headId, builder.getDirCache.writeTree(inserter),
-          Constants.HEAD, loginAccount.fullName, loginAccount.mailAddress, "Initial commit")
-      }
-    }
-
-    // Create Wiki repository
-    createWikiRepository(loginAccount, owner, name)
-
-    // Record activity
-    recordCreateRepositoryActivity(owner, name, loginUserName)
-  }
-
-  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(){
     override def validate(name: String, value: String, messages: Messages): Option[String] =
       if(getAccountByUserName(value).isEmpty) Some("User or group does not exist.") else None

src/main/scala/gitbucket/core/controller/ApiController.scala

@@ -0,0 +1,389 @@
+package gitbucket.core.controller
+
+import gitbucket.core.api._
+import gitbucket.core.model._
+import gitbucket.core.service.IssuesService.IssueSearchCondition
+import gitbucket.core.service.PullRequestService._
+import gitbucket.core.service._
+import gitbucket.core.util.ControlUtil._
+import gitbucket.core.util.Directory._
+import gitbucket.core.util.JGitUtil.CommitInfo
+import gitbucket.core.util._
+import gitbucket.core.util.Implicits._
+import org.eclipse.jgit.api.Git
+import org.scalatra.{NoContent, UnprocessableEntity, Created}
+import scala.collection.JavaConverters._
+
+class ApiController extends ApiControllerBase
+  with RepositoryService
+  with AccountService
+  with ProtectedBranchService
+  with IssuesService
+  with LabelsService
+  with PullRequestService
+  with CommitStatusService
+  with RepositoryCreationService
+  with HandleCommentService
+  with WebHookService
+  with WebHookPullRequestService
+  with WebHookIssueCommentService
+  with WikiService
+  with ActivityService
+  with OwnerAuthenticator
+  with UsersAuthenticator
+  with GroupManagerAuthenticator
+  with ReferrerAuthenticator
+  with ReadableUsersAuthenticator
+  with CollaboratorsAuthenticator
+
+trait ApiControllerBase extends ControllerBase {
+  self: RepositoryService
+    with AccountService
+    with ProtectedBranchService
+    with IssuesService
+    with LabelsService
+    with PullRequestService
+    with CommitStatusService
+    with RepositoryCreationService
+    with HandleCommentService
+    with OwnerAuthenticator
+    with UsersAuthenticator
+    with GroupManagerAuthenticator
+    with ReferrerAuthenticator
+    with ReadableUsersAuthenticator
+    with CollaboratorsAuthenticator =>
+
+  /**
+   * https://developer.github.com/v3/users/#get-a-single-user
+   */
+  get("/api/v3/users/:userName") {
+    getAccountByUserName(params("userName")).map { account =>
+      JsonFormat(ApiUser(account))
+    } getOrElse NotFound
+  }
+
+  /**
+   * https://developer.github.com/v3/users/#get-the-authenticated-user
+   */
+  get("/api/v3/user") {
+    context.loginAccount.map { account =>
+      JsonFormat(ApiUser(account))
+    } getOrElse Unauthorized
+  }
+
+  /**
+   * Create user repository
+   * https://developer.github.com/v3/repos/#create
+   */
+  post("/api/v3/user/repos")(usersOnly {
+    val owner = context.loginAccount.get.userName
+    (for {
+      data <- extractFromJsonBody[CreateARepository] if data.isValid
+    } yield {
+      LockUtil.lock(s"${owner}/${data.name}") {
+        if(getRepository(owner, data.name).isEmpty){
+          createRepository(context.loginAccount.get, owner, data.name, data.description, data.`private`, data.auto_init)
+          val repository = getRepository(owner, data.name).get
+          JsonFormat(ApiRepository(repository, ApiUser(getAccountByUserName(owner).get)))
+        } else {
+          ApiError(
+            "A repository with this name already exists on this account",
+            Some("https://developer.github.com/v3/repos/#create")
+          )
+        }
+      }
+    }) getOrElse NotFound
+  })
+
+  /**
+   * Create group repository
+   * https://developer.github.com/v3/repos/#create
+   */
+  post("/api/v3/orgs/:org/repos")(managersOnly {
+    val groupName = params("org")
+    (for {
+      data <- extractFromJsonBody[CreateARepository] if data.isValid
+    } yield {
+      LockUtil.lock(s"${groupName}/${data.name}") {
+        if(getRepository(groupName, data.name).isEmpty){
+          createRepository(context.loginAccount.get, groupName, data.name, data.description, data.`private`, data.auto_init)
+          val repository = getRepository(groupName, data.name).get
+          JsonFormat(ApiRepository(repository, ApiUser(getAccountByUserName(groupName).get)))
+        } else {
+          ApiError(
+            "A repository with this name already exists for this group",
+            Some("https://developer.github.com/v3/repos/#create")
+          )
+        }
+      }
+    }) getOrElse NotFound
+  })
+
+  /** https://developer.github.com/v3/repos/#enabling-and-disabling-branch-protection */
+  patch("/api/v3/repos/:owner/:repo/branches/:branch")(ownerOnly { repository =>
+    import gitbucket.core.api._
+    (for{
+      branch <- params.get("branch") if repository.branchList.find(_ == branch).isDefined
+      protection <- extractFromJsonBody[ApiBranchProtection.EnablingAndDisabling].map(_.protection)
+    } yield {
+      if(protection.enabled){
+        enableBranchProtection(repository.owner, repository.name, branch, protection.status.enforcement_level == ApiBranchProtection.Everyone, protection.status.contexts)
+      } else {
+        disableBranchProtection(repository.owner, repository.name, branch)
+      }
+      JsonFormat(ApiBranch(branch, protection)(RepositoryName(repository)))
+    }) getOrElse NotFound
+  })
+
+  /**
+   * @see https://developer.github.com/v3/rate_limit/#get-your-current-rate-limit-status
+   * but not enabled.
+   */
+  get("/api/v3/rate_limit"){
+    contentType = formats("json")
+    // this message is same as github enterprise...
+    org.scalatra.NotFound(ApiError("Rate limiting is not enabled."))
+  }
+
+  /**
+   * https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue
+   */
+  get("/api/v3/repos/:owner/:repository/issues/:id/comments")(referrersOnly { repository =>
+    (for{
+      issueId <- params("id").toIntOpt
+      comments = getCommentsForApi(repository.owner, repository.name, issueId.toInt)
+    } yield {
+      JsonFormat(comments.map{ case (issueComment, user, issue) => ApiComment(issueComment, RepositoryName(repository), issueId, ApiUser(user), issue.isPullRequest) })
+    }).getOrElse(NotFound)
+  })
+
+  /**
+   * https://developer.github.com/v3/issues/comments/#create-a-comment
+   */
+  post("/api/v3/repos/:owner/:repository/issues/:id/comments")(readableUsersOnly { repository =>
+    (for{
+      issueId      <- params("id").toIntOpt
+      issue        <- getIssue(repository.owner, repository.name, issueId.toString)
+      body         <- extractFromJsonBody[CreateAComment].map(_.body) if ! body.isEmpty
+      action       =  params.get("action").filter(_ => isEditable(issue.userName, issue.repositoryName, issue.openedUserName))
+      (issue, id)  <- handleComment(issue, Some(body), repository, action)
+      issueComment <- getComment(repository.owner, repository.name, id.toString())
+    } yield {
+      JsonFormat(ApiComment(issueComment, RepositoryName(repository), issueId, ApiUser(context.loginAccount.get), issue.isPullRequest))
+    }) getOrElse NotFound
+  })
+
+  /**
+   * List all labels for this repository
+   * https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository
+   */
+  get("/api/v3/repos/:owner/:repository/labels")(referrersOnly { repository =>
+    JsonFormat(getLabels(repository.owner, repository.name).map { label =>
+      ApiLabel(label, RepositoryName(repository))
+    })
+  })
+
+  /**
+   * Get a single label
+   * https://developer.github.com/v3/issues/labels/#get-a-single-label
+   */
+  get("/api/v3/repos/:owner/:repository/labels/:labelName")(referrersOnly { repository =>
+    getLabel(repository.owner, repository.name, params("labelName")).map { label =>
+      JsonFormat(ApiLabel(label, RepositoryName(repository)))
+    } getOrElse NotFound()
+  })
+
+  /**
+   * Create a label
+   * https://developer.github.com/v3/issues/labels/#create-a-label
+   */
+  post("/api/v3/repos/:owner/:repository/labels")(collaboratorsOnly { repository =>
+    (for{
+      data <- extractFromJsonBody[CreateALabel] if data.isValid
+    } yield {
+      LockUtil.lock(RepositoryName(repository).fullName) {
+        if (getLabel(repository.owner, repository.name, data.name).isEmpty) {
+          val labelId = createLabel(repository.owner, repository.name, data.name, data.color)
+          getLabel(repository.owner, repository.name, labelId).map { label =>
+            Created(JsonFormat(ApiLabel(label, RepositoryName(repository))))
+          } getOrElse NotFound()
+        } else {
+          // TODO ApiError should support errors field to enhance compatibility of GitHub API
+          UnprocessableEntity(ApiError(
+            "Validation Failed",
+            Some("https://developer.github.com/v3/issues/labels/#create-a-label")
+          ))
+        }
+      }
+    }) getOrElse NotFound()
+  })
+
+  /**
+   * Update a label
+   * https://developer.github.com/v3/issues/labels/#update-a-label
+   */
+  patch("/api/v3/repos/:owner/:repository/labels/:labelName")(collaboratorsOnly { repository =>
+    (for{
+      data <- extractFromJsonBody[CreateALabel] if data.isValid
+    } yield {
+      LockUtil.lock(RepositoryName(repository).fullName) {
+        getLabel(repository.owner, repository.name, params("labelName")).map { label =>
+          if (getLabel(repository.owner, repository.name, data.name).isEmpty) {
+            updateLabel(repository.owner, repository.name, label.labelId, data.name, data.color)
+            JsonFormat(ApiLabel(
+              getLabel(repository.owner, repository.name, label.labelId).get,
+              RepositoryName(repository)))
+          } else {
+            // TODO ApiError should support errors field to enhance compatibility of GitHub API
+            UnprocessableEntity(ApiError(
+              "Validation Failed",
+              Some("https://developer.github.com/v3/issues/labels/#create-a-label")))
+          }
+        } getOrElse NotFound()
+      }
+    }) getOrElse NotFound()
+  })
+
+  /**
+   * Delete a label
+   * https://developer.github.com/v3/issues/labels/#delete-a-label
+   */
+  delete("/api/v3/repos/:owner/:repository/labels/:labelName")(collaboratorsOnly { repository =>
+    LockUtil.lock(RepositoryName(repository).fullName) {
+      getLabel(repository.owner, repository.name, params("labelName")).map { label =>
+        deleteLabel(repository.owner, repository.name, label.labelId)
+        NoContent()
+      } getOrElse NotFound()
+    }
+  })
+
+  /**
+   * https://developer.github.com/v3/pulls/#list-pull-requests
+   */
+  get("/api/v3/repos/:owner/:repository/pulls")(referrersOnly { repository =>
+    val page       = IssueSearchCondition.page(request)
+    // TODO: more api spec condition
+    val condition = IssueSearchCondition(request)
+    val baseOwner = getAccountByUserName(repository.owner).get
+    val issues:List[(Issue, Account, Int, PullRequest, Repository, Account)] = searchPullRequestByApi(condition, (page - 1) * PullRequestLimit, PullRequestLimit, repository.owner -> repository.name)
+    JsonFormat(issues.map{case (issue, issueUser, commentCount, pullRequest, headRepo, headOwner) =>
+      ApiPullRequest(
+        issue,
+        pullRequest,
+        ApiRepository(headRepo, ApiUser(headOwner)),
+        ApiRepository(repository, ApiUser(baseOwner)),
+        ApiUser(issueUser)) })
+  })
+
+  /**
+   * https://developer.github.com/v3/pulls/#get-a-single-pull-request
+   */
+  get("/api/v3/repos/:owner/:repository/pulls/:id")(referrersOnly { repository =>
+    (for{
+      issueId <- params("id").toIntOpt
+      (issue, pullRequest) <- getPullRequest(repository.owner, repository.name, issueId)
+      users = getAccountsByUserNames(Set(repository.owner, pullRequest.requestUserName, issue.openedUserName), Set())
+      baseOwner <- users.get(repository.owner)
+      headOwner <- users.get(pullRequest.requestUserName)
+      issueUser <- users.get(issue.openedUserName)
+      headRepo  <- getRepository(pullRequest.requestUserName, pullRequest.requestRepositoryName)
+    } yield {
+      JsonFormat(ApiPullRequest(
+        issue,
+        pullRequest,
+        ApiRepository(headRepo, ApiUser(headOwner)),
+        ApiRepository(repository, ApiUser(baseOwner)),
+        ApiUser(issueUser)))
+    }).getOrElse(NotFound)
+  })
+
+  /**
+   * https://developer.github.com/v3/pulls/#list-commits-on-a-pull-request
+   */
+  get("/api/v3/repos/:owner/:repository/pulls/:id/commits")(referrersOnly { repository =>
+    val owner = repository.owner
+    val name = repository.name
+    params("id").toIntOpt.flatMap{ issueId =>
+      getPullRequest(owner, name, issueId) map { case(issue, pullreq) =>
+        using(Git.open(getRepositoryDir(owner, name))){ git =>
+          val oldId = git.getRepository.resolve(pullreq.commitIdFrom)
+          val newId = git.getRepository.resolve(pullreq.commitIdTo)
+          val repoFullName = RepositoryName(repository)
+          val commits = git.log.addRange(oldId, newId).call.iterator.asScala.map(c => ApiCommitListItem(new CommitInfo(c), repoFullName)).toList
+          JsonFormat(commits)
+        }
+      }
+    } getOrElse NotFound
+  })
+
+  /**
+   * https://developer.github.com/v3/repos/#get
+   */
+  get("/api/v3/repos/:owner/:repository")(referrersOnly { repository =>
+    JsonFormat(ApiRepository(repository, ApiUser(getAccountByUserName(repository.owner).get)))
+  })
+
+  /**
+   * https://developer.github.com/v3/repos/statuses/#create-a-status
+   */
+  post("/api/v3/repos/:owner/:repo/statuses/:sha")(collaboratorsOnly { repository =>
+    (for{
+      ref <- params.get("sha")
+      sha <- JGitUtil.getShaByRef(repository.owner, repository.name, ref)
+      data <- extractFromJsonBody[CreateAStatus] if data.isValid
+      creator <- context.loginAccount
+      state <- CommitState.valueOf(data.state)
+      statusId = createCommitStatus(repository.owner, repository.name, sha, data.context.getOrElse("default"),
+        state, data.target_url, data.description, new java.util.Date(), creator)
+      status <- getCommitStatus(repository.owner, repository.name, statusId)
+    } yield {
+      JsonFormat(ApiCommitStatus(status, ApiUser(creator)))
+    }) getOrElse NotFound
+  })
+
+  /**
+   * https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref
+   *
+   * ref is Ref to list the statuses from. It can be a SHA, a branch name, or a tag name.
+   */
+  val listStatusesRoute = get("/api/v3/repos/:owner/:repo/commits/:ref/statuses")(referrersOnly { repository =>
+    (for{
+      ref <- params.get("ref")
+      sha <- JGitUtil.getShaByRef(repository.owner, repository.name, ref)
+    } yield {
+      JsonFormat(getCommitStatuesWithCreator(repository.owner, repository.name, sha).map{ case(status, creator) =>
+        ApiCommitStatus(status, ApiUser(creator))
+      })
+    }) getOrElse NotFound
+  })
+
+  /**
+   * https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref
+   *
+   * legacy route
+   */
+  get("/api/v3/repos/:owner/:repo/statuses/:ref"){
+    listStatusesRoute.action()
+  }
+
+  /**
+   * https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref
+   *
+   * ref is Ref to list the statuses from. It can be a SHA, a branch name, or a tag name.
+   */
+  get("/api/v3/repos/:owner/:repo/commits/:ref/status")(referrersOnly { repository =>
+    (for{
+      ref <- params.get("ref")
+      owner <- getAccountByUserName(repository.owner)
+      sha <- JGitUtil.getShaByRef(repository.owner, repository.name, ref)
+    } yield {
+      val statuses = getCommitStatuesWithCreator(repository.owner, repository.name, sha)
+      JsonFormat(ApiCombinedCommitStatus(sha, statuses, ApiRepository(repository, owner)))
+    }) getOrElse NotFound
+  })
+
+  private def isEditable(owner: String, repository: String, author: String)(implicit context: Context): Boolean =
+    hasWritePermission(owner, repository, context.loginAccount) || author == context.loginAccount.get.userName
+
+}
+

src/main/scala/gitbucket/core/controller/ControllerBase.scala

@@ -8,7 +8,7 @@ import gitbucket.core.util.Directory._
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util._
 
-import jp.sf.amateras.scalatra.forms._
+import io.github.gitbucket.scalatra.forms._
 import org.apache.commons.io.FileUtils
 import org.json4s._
 import org.scalatra._
@@ -28,7 +28,11 @@ abstract class ControllerBase extends ScalatraFilter
   with ClientSideValidationFormSupport with JacksonJsonSupport with I18nSupport with FlashMapSupport with Validations
   with SystemSettingsService {
 
-  implicit val jsonFormats = DefaultFormats
+  implicit val jsonFormats = gitbucket.core.api.JsonFormat.jsonFormats
+
+  before("/api/v3/*") {
+    contentType = formats("json")
+  }
 
 // TODO Scala 2.11
 //  // Don't set content type via Accept header.
@@ -176,7 +180,6 @@ abstract class ControllerBase extends ScalatraFilter
  * Context object for the current request.
  */
 case class Context(settings: SystemSettingsService.SystemSettings, loginAccount: Option[Account], request: HttpServletRequest){
-
   val path = settings.baseUrl.getOrElse(request.getContextPath)
   val currentPath = request.getRequestURI.substring(request.getContextPath.length)
   val baseUrl = settings.baseUrl(request)

src/main/scala/gitbucket/core/controller/DashboardController.scala

@@ -94,7 +94,7 @@ trait DashboardControllerBase extends ControllerBase {
 
     val userName  = context.loginAccount.get.userName
     val condition = getOrCreateCondition(Keys.Session.DashboardIssues, filter, userName)
-    val userRepos = getUserRepositories(userName, context.baseUrl, true).map(repo => repo.owner -> repo.name)
+    val userRepos = getUserRepositories(userName, true).map(repo => repo.owner -> repo.name)
     val page      = IssueSearchCondition.page(request)
 
     html.issues(
@@ -108,7 +108,9 @@ trait DashboardControllerBase extends ControllerBase {
         case _           => condition.copy(author    = Some(userName))
       },
       filter,
-      getGroupNames(userName))
+      getGroupNames(userName),
+      getVisibleRepositories(context.loginAccount, withoutPhysicalInfo = true),
+      getUserRepositories(userName, withoutPhysicalInfo = true))
   }
 
   private def searchPullRequests(filter: String) = {
@@ -131,7 +133,9 @@ trait DashboardControllerBase extends ControllerBase {
         case _           => condition.copy(author    = Some(userName))
       },
       filter,
-      getGroupNames(userName))
+      getGroupNames(userName),
+      getVisibleRepositories(context.loginAccount, withoutPhysicalInfo = true),
+      getUserRepositories(userName, withoutPhysicalInfo = true))
   }
 
 

src/main/scala/gitbucket/core/controller/FileUploadController.scala

@@ -1,18 +1,24 @@
 package gitbucket.core.controller
 
-import gitbucket.core.util.{Keys, FileUtil}
+import gitbucket.core.model.Account
+import gitbucket.core.service.{AccountService, RepositoryService}
+import gitbucket.core.servlet.Database
+import gitbucket.core.util._
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Directory._
+import org.eclipse.jgit.api.Git
+import org.eclipse.jgit.dircache.DirCache
+import org.eclipse.jgit.lib.{FileMode, Constants}
 import org.scalatra._
 import org.scalatra.servlet.{MultipartConfig, FileUploadSupport, FileItem}
-import org.apache.commons.io.FileUtils
+import org.apache.commons.io.{IOUtils, FileUtils}
 
 /**
  * Provides Ajax based file upload functionality.
  *
  * This servlet saves uploaded file.
  */
-class FileUploadController extends ScalatraServlet with FileUploadSupport {
+class FileUploadController extends ScalatraServlet with FileUploadSupport with RepositoryService with AccountService {
 
   configureMultipartHandling(MultipartConfig(maxFileSize = Some(3 * 1024 * 1024)))
 
@@ -31,6 +37,54 @@ class FileUploadController extends ScalatraServlet with FileUploadSupport {
     }, FileUtil.isUploadableType)
   }
 
+  post("/wiki/:owner/:repository"){
+    // Don't accept not logged-in users
+    session.get(Keys.Session.LoginAccount).collect { case loginAccount: Account =>
+      val owner      = params("owner")
+      val repository = params("repository")
+
+      // Check whether logged-in user is collaborator
+      collaboratorsOnly(owner, repository, loginAccount){
+        execute({ (file, fileId) =>
+          val fileName   = file.getName
+          LockUtil.lock(s"${owner}/${repository}/wiki") {
+            using(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
+              val builder  = DirCache.newInCore.builder()
+              val inserter = git.getRepository.newObjectInserter()
+              val headId   = git.getRepository.resolve(Constants.HEAD + "^{commit}")
+
+              if(headId != null){
+                JGitUtil.processTree(git, headId){ (path, tree) =>
+                  if(path != fileName){
+                    builder.add(JGitUtil.createDirCacheEntry(path, tree.getEntryFileMode, tree.getEntryObjectId))
+                  }
+                }
+              }
+
+              val bytes = IOUtils.toByteArray(file.getInputStream)
+              builder.add(JGitUtil.createDirCacheEntry(fileName, FileMode.REGULAR_FILE, inserter.insert(Constants.OBJ_BLOB, bytes)))
+              builder.finish()
+
+              val newHeadId = JGitUtil.createNewCommit(git, inserter, headId, builder.getDirCache.writeTree(inserter),
+                Constants.HEAD, loginAccount.userName, loginAccount.mailAddress, s"Uploaded ${fileName}")
+
+              fileName
+            }
+          }
+        }, FileUtil.isImage)
+      }
+    } getOrElse BadRequest
+  }
+
+  private def collaboratorsOnly(owner: String, repository: String, loginAccount: Account)(action: => Any): Any = {
+    implicit val session = Database.getSession(request)
+    loginAccount match {
+      case x if(x.isAdmin) => action
+      case x if(getCollaborators(owner, repository).contains(x.userName)) => action
+      case _ => BadRequest
+    }
+  }
+
   private def execute(f: (FileItem, String) => Unit, mimeTypeChcker: (String) => Boolean) = fileParams.get("file") match {
     case Some(file) if(mimeTypeChcker(file.name)) =>
       defining(FileUtil.generateFileId){ fileId =>

src/main/scala/gitbucket/core/controller/IndexController.scala

@@ -1,36 +1,46 @@
 package gitbucket.core.controller
 
-import gitbucket.core.api._
 import gitbucket.core.helper.xml
-import gitbucket.core.html
 import gitbucket.core.model.Account
-import gitbucket.core.service.{RepositoryService, ActivityService, AccountService}
+import gitbucket.core.service._
 import gitbucket.core.util.Implicits._
-import gitbucket.core.util.{LDAPUtil, Keys, UsersAuthenticator}
+import gitbucket.core.util.ControlUtil._
+import gitbucket.core.util.{LDAPUtil, Keys, UsersAuthenticator, ReferrerAuthenticator, StringUtil}
 
-import jp.sf.amateras.scalatra.forms._
+import io.github.gitbucket.scalatra.forms._
 
 
 class IndexController extends IndexControllerBase 
-  with RepositoryService with ActivityService with AccountService with UsersAuthenticator
+  with RepositoryService with ActivityService with AccountService with RepositorySearchService with IssuesService
+  with UsersAuthenticator with ReferrerAuthenticator
 
 
 trait IndexControllerBase extends ControllerBase {
-  self: RepositoryService with ActivityService with AccountService with UsersAuthenticator =>
+  self: RepositoryService with ActivityService with AccountService with RepositorySearchService
+    with UsersAuthenticator with ReferrerAuthenticator =>
 
   case class SignInForm(userName: String, password: String)
 
-  val form = mapping(
+  val signinForm = mapping(
     "userName" -> trim(label("Username", text(required))),
     "password" -> trim(label("Password", text(required)))
   )(SignInForm.apply)
 
+  val searchForm = mapping(
+    "query"      -> trim(text(required)),
+    "owner"      -> trim(text(required)),
+    "repository" -> trim(text(required))
+  )(SearchForm.apply)
+
+  case class SearchForm(query: String, owner: String, repository: String)
+
+
   get("/"){
     val loginAccount = context.loginAccount
     if(loginAccount.isEmpty) {
-        html.index(getRecentActivities(),
-            getVisibleRepositories(loginAccount, context.baseUrl, withoutPhysicalInfo = true),
-            loginAccount.map{ account => getUserRepositories(account.userName, context.baseUrl, withoutPhysicalInfo = true) }.getOrElse(Nil)
+        gitbucket.core.html.index(getRecentActivities(),
+            getVisibleRepositories(loginAccount, withoutPhysicalInfo = true),
+            loginAccount.map{ account => getUserRepositories(account.userName, withoutPhysicalInfo = true) }.getOrElse(Nil)
         )
     } else {
         val loginUserName = loginAccount.get.userName
@@ -39,9 +49,9 @@ trait IndexControllerBase extends ControllerBase {
         
         visibleOwnerSet ++= loginUserGroups
 
-        html.index(getRecentActivitiesByOwners(visibleOwnerSet),
-            getVisibleRepositories(loginAccount, context.baseUrl, withoutPhysicalInfo = true),
-            loginAccount.map{ account => getUserRepositories(account.userName, context.baseUrl, withoutPhysicalInfo = true) }.getOrElse(Nil) 
+        gitbucket.core.html.index(getRecentActivitiesByOwners(visibleOwnerSet),
+            getVisibleRepositories(loginAccount, withoutPhysicalInfo = true),
+            loginAccount.map{ account => getUserRepositories(account.userName, withoutPhysicalInfo = true) }.getOrElse(Nil) 
         )
     }
   }
@@ -51,10 +61,10 @@ trait IndexControllerBase extends ControllerBase {
     if(redirect.isDefined && redirect.get.startsWith("/")){
       flash += Keys.Flash.Redirect -> redirect.get
     }
-    html.signin()
+    gitbucket.core.html.signin()
   }
 
-  post("/signin", form){ form =>
+  post("/signin", signinForm){ form =>
     authenticate(context.settings, form.userName, form.password) match {
       case Some(account) => signin(account)
       case None          => redirect("/signin")
@@ -110,13 +120,40 @@ trait IndexControllerBase extends ControllerBase {
     getAccountByUserName(params("userName")).isDefined
   })
 
-  /**
-   * @see https://developer.github.com/v3/rate_limit/#get-your-current-rate-limit-status
-   * but not enabled.
-   */
-  get("/api/v3/rate_limit"){
-    contentType = formats("json")
-    // this message is same as github enterprise...
-    org.scalatra.NotFound(ApiError("Rate limiting is not enabled."))
+  // TODO Move to RepositoryViwerController?
+  post("/search", searchForm){ form =>
+    redirect(s"/${form.owner}/${form.repository}/search?q=${StringUtil.urlEncode(form.query)}")
   }
+
+  // TODO Move to RepositoryViwerController?
+  get("/:owner/:repository/search")(referrersOnly { repository =>
+    defining(params("q").trim, params.getOrElse("type", "code")){ case (query, target) =>
+      val page   = try {
+        val i = params.getOrElse("page", "1").toInt
+        if(i <= 0) 1 else i
+      } catch {
+        case e: NumberFormatException => 1
+      }
+
+      target.toLowerCase match {
+        case "issue" => gitbucket.core.search.html.issues(
+          countFiles(repository.owner, repository.name, query),
+          searchIssues(repository.owner, repository.name, query),
+          countWikiPages(repository.owner, repository.name, query),
+          query, page, repository)
+
+        case "wiki" => gitbucket.core.search.html.wiki(
+          countFiles(repository.owner, repository.name, query),
+          countIssues(repository.owner, repository.name, query),
+          searchWikiPages(repository.owner, repository.name, query),
+          query, page, repository)
+
+        case _ => gitbucket.core.search.html.code(
+          searchFiles(repository.owner, repository.name, query),
+          countIssues(repository.owner, repository.name, query),
+          countWikiPages(repository.owner, repository.name, query),
+          query, page, repository)
+      }
+    }
+  })
 }

src/main/scala/gitbucket/core/controller/IssuesController.scala

@@ -1,8 +1,6 @@
 package gitbucket.core.controller
 
-import gitbucket.core.api._
 import gitbucket.core.issues.html
-import gitbucket.core.model.Issue
 import gitbucket.core.service.IssuesService._
 import gitbucket.core.service._
 import gitbucket.core.util.ControlUtil._
@@ -11,16 +9,16 @@ import gitbucket.core.util._
 import gitbucket.core.view
 import gitbucket.core.view.Markdown
 
-import jp.sf.amateras.scalatra.forms._
+import io.github.gitbucket.scalatra.forms._
 import org.scalatra.Ok
 
 
 class IssuesController extends IssuesControllerBase
-  with IssuesService with RepositoryService with AccountService with LabelsService with MilestonesService with ActivityService
+  with IssuesService with RepositoryService with AccountService with LabelsService with MilestonesService with ActivityService with HandleCommentService
   with ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator with PullRequestService with WebHookIssueCommentService
 
 trait IssuesControllerBase extends ControllerBase {
-  self: IssuesService with RepositoryService with AccountService with LabelsService with MilestonesService with ActivityService
+  self: IssuesService with RepositoryService with AccountService with LabelsService with MilestonesService with ActivityService with HandleCommentService
     with ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator with PullRequestService with WebHookIssueCommentService =>
 
   case class IssueCreateForm(title: String, content: Option[String],
@@ -78,18 +76,6 @@ trait IssuesControllerBase extends ControllerBase {
     }
   })
 
-  /**
-   * https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue
-   */
-  get("/api/v3/repos/:owner/:repository/issues/:id/comments")(referrersOnly { repository =>
-    (for{
-      issueId <- params("id").toIntOpt
-      comments = getCommentsForApi(repository.owner, repository.name, issueId.toInt)
-    } yield {
-      JsonFormat(comments.map{ case (issueComment, user, issue) => ApiComment(issueComment, RepositoryName(repository), issueId, ApiUser(user), issue.isPullRequest) })
-    }).getOrElse(NotFound)
-  })
-
   get("/:owner/:repository/issues/new")(readableUsersOnly { repository =>
     defining(repository.owner, repository.name){ case (owner, name) =>
       html.create(
@@ -128,7 +114,7 @@ trait IssuesControllerBase extends ControllerBase {
 
       getIssue(owner, name, issueId.toString).foreach { issue =>
         // extract references and create refer comment
-        createReferComment(owner, name, issue, form.title + " " + form.content.getOrElse(""))
+        createReferComment(owner, name, issue, form.title + " " + form.content.getOrElse(""), context.loginAccount.get)
 
         // call web hooks
         callIssuesWebHook("opened", repository, issue, context.baseUrl, context.loginAccount.get)
@@ -150,7 +136,7 @@ trait IssuesControllerBase extends ControllerBase {
           // update issue
           updateIssue(owner, name, issue.issueId, title, issue.content)
           // extract references and create refer comment
-          createReferComment(owner, name, issue.copy(title = title), title)
+          createReferComment(owner, name, issue.copy(title = title), title, context.loginAccount.get)
 
           redirect(s"/${owner}/${name}/issues/_data/${issue.issueId}")
         } else Unauthorized
@@ -165,7 +151,7 @@ trait IssuesControllerBase extends ControllerBase {
           // update issue
           updateIssue(owner, name, issue.issueId, issue.title, content)
           // extract references and create refer comment
-          createReferComment(owner, name, issue, content.getOrElse(""))
+          createReferComment(owner, name, issue, content.getOrElse(""), context.loginAccount.get)
 
           redirect(s"/${owner}/${name}/issues/_data/${issue.issueId}")
         } else Unauthorized
@@ -174,30 +160,22 @@ trait IssuesControllerBase extends ControllerBase {
   })
 
   post("/:owner/:repository/issue_comments/new", commentForm)(readableUsersOnly { (form, repository) =>
-    handleComment(form.issueId, Some(form.content), repository)() map { case (issue, id) =>
-      redirect(s"/${repository.owner}/${repository.name}/${
-        if(issue.isPullRequest) "pull" else "issues"}/${form.issueId}#comment-${id}")
+    getIssue(repository.owner, repository.name, form.issueId.toString).flatMap { issue =>
+      val actionOpt = params.get("action").filter(_ => isEditable(issue.userName, issue.repositoryName, issue.openedUserName))
+      handleComment(issue, Some(form.content), repository, actionOpt) map { case (issue, id) =>
+        redirect(s"/${repository.owner}/${repository.name}/${
+          if(issue.isPullRequest) "pull" else "issues"}/${form.issueId}#comment-${id}")
+      }
     } getOrElse NotFound
   })
 
-  /**
-   * https://developer.github.com/v3/issues/comments/#create-a-comment
-   */
-  post("/api/v3/repos/:owner/:repository/issues/:id/comments")(readableUsersOnly { repository =>
-    (for{
-      issueId <- params("id").toIntOpt
-      body <- extractFromJsonBody[CreateAComment].map(_.body) if ! body.isEmpty
-      (issue, id) <- handleComment(issueId, Some(body), repository)()
-      issueComment <- getComment(repository.owner, repository.name, id.toString())
-    } yield {
-      JsonFormat(ApiComment(issueComment, RepositoryName(repository), issueId, ApiUser(context.loginAccount.get), issue.isPullRequest))
-    }) getOrElse NotFound
-  })
-
   post("/:owner/:repository/issue_comments/state", issueStateForm)(readableUsersOnly { (form, repository) =>
-    handleComment(form.issueId, form.content, repository)() map { case (issue, id) =>
-      redirect(s"/${repository.owner}/${repository.name}/${
-        if(issue.isPullRequest) "pull" else "issues"}/${form.issueId}#comment-${id}")
+    getIssue(repository.owner, repository.name, form.issueId.toString).flatMap { issue =>
+      val actionOpt = params.get("action").filter(_ => isEditable(issue.userName, issue.repositoryName, issue.openedUserName))
+      handleComment(issue, form.content, repository, actionOpt) map { case (issue, id) =>
+        redirect(s"/${repository.owner}/${repository.name}/${
+          if(issue.isPullRequest) "pull" else "issues"}/${form.issueId}#comment-${id}")
+      }
     } getOrElse NotFound
   })
 
@@ -315,8 +293,16 @@ trait IssuesControllerBase extends ControllerBase {
   post("/:owner/:repository/issues/batchedit/state")(collaboratorsOnly { repository =>
     defining(params.get("value")){ action =>
       action match {
-        case Some("open")  => executeBatch(repository) { handleComment(_, None, repository)( _ => Some("reopen")) }
-        case Some("close") => executeBatch(repository) { handleComment(_, None, repository)( _ => Some("close"))  }
+        case Some("open")  => executeBatch(repository) { issueId =>
+          getIssue(repository.owner, repository.name, issueId.toString).foreach { issue =>
+            handleComment(issue, None, repository, Some("reopen"))
+          }
+        }
+        case Some("close") => executeBatch(repository) { issueId =>
+          getIssue(repository.owner, repository.name, issueId.toString).foreach { issue =>
+            handleComment(issue, None, repository, Some("close"))
+          }
+        }
         case _ => // TODO BadRequest
       }
     }
@@ -373,99 +359,6 @@ trait IssuesControllerBase extends ControllerBase {
     }
   }
 
-  // TODO Same method exists in PullRequestController. Should it moved to IssueService?
-  private def createReferComment(owner: String, repository: String, fromIssue: Issue, message: String) = {
-    StringUtil.extractIssueId(message).foreach { issueId =>
-      val content = fromIssue.issueId + ":" + fromIssue.title
-      if(getIssue(owner, repository, issueId).isDefined){
-        // Not add if refer comment already exist.
-        if(!getComments(owner, repository, issueId.toInt).exists { x => x.action == "refer" && x.content == content }) {
-          createComment(owner, repository, context.loginAccount.get.userName, issueId.toInt, content, "refer")
-        }
-      }
-    }
-  }
-
-  /**
-   * @see [[https://github.com/takezoe/gitbucket/wiki/CommentAction]]
-   */
-  private def handleComment(issueId: Int, content: Option[String], repository: RepositoryService.RepositoryInfo)
-      (getAction: Issue => Option[String] =
-           p1 => params.get("action").filter(_ => isEditable(p1.userName, p1.repositoryName, p1.openedUserName))) = {
-
-    defining(repository.owner, repository.name){ case (owner, name) =>
-      val userName = context.loginAccount.get.userName
-
-      getIssue(owner, name, issueId.toString) flatMap { issue =>
-        val (action, recordActivity) =
-          getAction(issue)
-            .collect {
-              case "close" if(!issue.closed) => true  ->
-                (Some("close")  -> Some(if(issue.isPullRequest) recordClosePullRequestActivity _ else recordCloseIssueActivity _))
-              case "reopen" if(issue.closed) => false ->
-                (Some("reopen") -> Some(recordReopenIssueActivity _))
-            }
-            .map { case (closed, t) =>
-              updateClosed(owner, name, issueId, closed)
-              t
-            }
-            .getOrElse(None -> None)
-
-        val commentId = (content, action) match {
-          case (None, None) => None
-          case (None, Some(action)) => Some(createComment(owner, name, userName, issueId, action.capitalize, action))
-          case (Some(content), _) => Some(createComment(owner, name, userName, issueId, content, action.map(_+ "_comment").getOrElse("comment")))
-        }
-
-        // record comment activity if comment is entered
-        content foreach {
-          (if(issue.isPullRequest) recordCommentPullRequestActivity _ else recordCommentIssueActivity _)
-          (owner, name, userName, issueId, _)
-        }
-        recordActivity foreach ( _ (owner, name, userName, issueId, issue.title) )
-
-        // extract references and create refer comment
-        content.map { content =>
-          createReferComment(owner, name, issue, content)
-        }
-
-        // call web hooks
-        action match {
-          case None => commentId.map{ commentIdSome => callIssueCommentWebHook(repository, issue, commentIdSome, context.loginAccount.get) }
-          case Some(act) => val webHookAction = act match {
-            case "open"   => "opened"
-            case "reopen" => "reopened"
-            case "close"  => "closed"
-            case _ => act
-          }
-          if(issue.isPullRequest){
-            callPullRequestWebHook(webHookAction, repository, issue.issueId, context.baseUrl, context.loginAccount.get)
-          } else {
-            callIssuesWebHook(webHookAction, repository, issue, context.baseUrl, context.loginAccount.get)
-          }
-        }
-
-        // notifications
-        Notifier() match {
-          case f =>
-            content foreach {
-              f.toNotify(repository, issue, _){
-                Notifier.msgComment(s"${context.baseUrl}/${owner}/${name}/${
-                  if(issue.isPullRequest) "pull" else "issues"}/${issueId}#comment-${commentId.get}")
-              }
-            }
-            action foreach {
-              f.toNotify(repository, issue, _){
-                Notifier.msgStatus(s"${context.baseUrl}/${owner}/${name}/issues/${issueId}")
-              }
-            }
-        }
-
-        commentId.map( issue -> _ )
-      }
-    }
-  }
-
   private def searchIssues(repository: RepositoryService.RepositoryInfo) = {
     defining(repository.owner, repository.name){ case (owner, repoName) =>
       val page       = IssueSearchCondition.page(request)

src/main/scala/gitbucket/core/controller/LabelsController.scala

@@ -4,7 +4,7 @@ import gitbucket.core.issues.labels.html
 import gitbucket.core.service.{RepositoryService, AccountService, IssuesService, LabelsService}
 import gitbucket.core.util.{ReferrerAuthenticator, CollaboratorsAuthenticator}
 import gitbucket.core.util.Implicits._
-import jp.sf.amateras.scalatra.forms._
+import io.github.gitbucket.scalatra.forms._
 import org.scalatra.i18n.Messages
 import org.scalatra.Ok
 
@@ -19,10 +19,11 @@ trait LabelsControllerBase extends ControllerBase {
   case class LabelForm(labelName: String, color: String)
 
   val labelForm = mapping(
-    "labelName"  -> trim(label("Label name", text(required, labelName, maxlength(100)))),
+    "labelName"  -> trim(label("Label name", text(required, labelName, uniqueLabelName, maxlength(100)))),
     "labelColor" -> trim(label("Color",      text(required, color)))
   )(LabelForm.apply)
 
+
   get("/:owner/:repository/issues/labels")(referrersOnly { repository =>
     html.list(
       getLabels(repository.owner, repository.name),
@@ -80,4 +81,16 @@ trait LabelsControllerBase extends ControllerBase {
       }
   }
 
+  private def uniqueLabelName: Constraint = new Constraint(){
+    override def validate(name: String, value: String, params: Map[String, String], messages: Messages): Option[String] = {
+      val owner = params("owner")
+      val repository = params("repository")
+      params.get("labelId").map { labelId =>
+        getLabel(owner, repository, value).filter(_.labelId != labelId.toInt).map(_ => "Name has already been taken.")
+      }.getOrElse {
+        getLabel(owner, repository, value).map(_ => "Name has already been taken.")
+      }
+    }
+  }
+
 }

src/main/scala/gitbucket/core/controller/MilestonesController.scala

@@ -4,7 +4,7 @@ import gitbucket.core.issues.milestones.html
 import gitbucket.core.service.{RepositoryService, MilestonesService, AccountService}
 import gitbucket.core.util.{ReferrerAuthenticator, CollaboratorsAuthenticator}
 import gitbucket.core.util.Implicits._
-import jp.sf.amateras.scalatra.forms._
+import io.github.gitbucket.scalatra.forms._
 
 class MilestonesController extends MilestonesControllerBase
   with MilestonesService with RepositoryService with AccountService

src/main/scala/gitbucket/core/controller/PluginsController.scala

@@ -1,11 +0,0 @@
-package gitbucket.core.controller
-
-import gitbucket.core.admin.plugins.html
-import gitbucket.core.plugin.PluginRegistry
-import gitbucket.core.util.AdminAuthenticator
-
-class PluginsController extends ControllerBase with AdminAuthenticator {
-  get("/admin/plugins")(adminOnly {
-    html.plugins(PluginRegistry().getPlugins())
-  })
-}

src/main/scala/gitbucket/core/controller/PullRequestsController.scala

@@ -1,7 +1,6 @@
 package gitbucket.core.controller
 
-import gitbucket.core.api._
-import gitbucket.core.model.{Account, CommitState, Repository, PullRequest, Issue}
+import gitbucket.core.model.WebHook
 import gitbucket.core.pulls.html
 import gitbucket.core.service.CommitStatusService
 import gitbucket.core.service.MergeService
@@ -16,7 +15,7 @@ import gitbucket.core.util._
 import gitbucket.core.view
 import gitbucket.core.view.helpers
 
-import jp.sf.amateras.scalatra.forms._
+import io.github.gitbucket.scalatra.forms._
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.lib.PersonIdent
 import org.slf4j.LoggerFactory
@@ -27,13 +26,13 @@ import scala.collection.JavaConverters._
 class PullRequestsController extends PullRequestsControllerBase
   with RepositoryService with AccountService with IssuesService with PullRequestService with MilestonesService with LabelsService
   with CommitsService with ActivityService with WebHookPullRequestService with ReferrerAuthenticator with CollaboratorsAuthenticator
-  with CommitStatusService with MergeService
+  with CommitStatusService with MergeService with ProtectedBranchService
 
 
 trait PullRequestsControllerBase extends ControllerBase {
   self: RepositoryService with AccountService with IssuesService with MilestonesService with LabelsService
     with CommitsService with ActivityService with PullRequestService with WebHookPullRequestService with ReferrerAuthenticator with CollaboratorsAuthenticator
-    with CommitStatusService with MergeService =>
+    with CommitStatusService with MergeService with ProtectedBranchService =>
 
   private val logger = LoggerFactory.getLogger(classOf[PullRequestsControllerBase])
 
@@ -82,24 +81,6 @@ trait PullRequestsControllerBase extends ControllerBase {
     }
   })
 
-  /**
-   * https://developer.github.com/v3/pulls/#list-pull-requests
-   */
-  get("/api/v3/repos/:owner/:repository/pulls")(referrersOnly { repository =>
-    val page       = IssueSearchCondition.page(request)
-    // TODO: more api spec condition
-    val condition = IssueSearchCondition(request)
-    val baseOwner = getAccountByUserName(repository.owner).get
-    val issues:List[(Issue, Account, Int, PullRequest, Repository, Account)] = searchPullRequestByApi(condition, (page - 1) * PullRequestLimit, PullRequestLimit, repository.owner -> repository.name)
-    JsonFormat(issues.map{case (issue, issueUser, commentCount, pullRequest, headRepo, headOwner) =>
-      ApiPullRequest(
-        issue,
-        pullRequest,
-        ApiRepository(headRepo, ApiUser(headOwner)),
-        ApiRepository(repository, ApiUser(baseOwner)),
-        ApiUser(issueUser)) })
-  })
-
   get("/:owner/:repository/pull/:id")(referrersOnly { repository =>
     params("id").toIntOpt.flatMap{ issueId =>
       val owner = repository.owner
@@ -119,71 +100,43 @@ trait PullRequestsControllerBase extends ControllerBase {
             commits,
             diffs,
             hasWritePermission(owner, name, context.loginAccount),
-            repository)
+            repository,
+            flash.toMap.map(f => f._1 -> f._2.toString))
         }
       }
     } getOrElse NotFound
   })
 
-  /**
-   * https://developer.github.com/v3/pulls/#get-a-single-pull-request
-   */
-  get("/api/v3/repos/:owner/:repository/pulls/:id")(referrersOnly { repository =>
-    (for{
-      issueId <- params("id").toIntOpt
-      (issue, pullRequest) <- getPullRequest(repository.owner, repository.name, issueId)
-      users = getAccountsByUserNames(Set(repository.owner, pullRequest.requestUserName, issue.openedUserName), Set())
-      baseOwner <- users.get(repository.owner)
-      headOwner <- users.get(pullRequest.requestUserName)
-      issueUser <- users.get(issue.openedUserName)
-      headRepo  <- getRepository(pullRequest.requestUserName, pullRequest.requestRepositoryName, baseUrl)
-    } yield {
-      JsonFormat(ApiPullRequest(
-        issue,
-        pullRequest,
-        ApiRepository(headRepo, ApiUser(headOwner)),
-        ApiRepository(repository, ApiUser(baseOwner)),
-        ApiUser(issueUser)))
-    }).getOrElse(NotFound)
-  })
-
-  /**
-   * https://developer.github.com/v3/pulls/#list-commits-on-a-pull-request
-   */
-  get("/api/v3/repos/:owner/:repository/pulls/:id/commits")(referrersOnly { repository =>
-    val owner = repository.owner
-    val name = repository.name
-    params("id").toIntOpt.flatMap{ issueId =>
-      getPullRequest(owner, name, issueId) map { case(issue, pullreq) =>
-        using(Git.open(getRepositoryDir(owner, name))){ git =>
-          val oldId = git.getRepository.resolve(pullreq.commitIdFrom)
-          val newId = git.getRepository.resolve(pullreq.commitIdTo)
-          val repoFullName = RepositoryName(repository)
-          val commits = git.log.addRange(oldId, newId).call.iterator.asScala.map(c => ApiCommitListItem(new CommitInfo(c), repoFullName)).toList
-          JsonFormat(commits)
-        }
-      }
-    } getOrElse NotFound
-  })
-
-  ajaxGet("/:owner/:repository/pull/:id/mergeguide")(collaboratorsOnly { repository =>
+  ajaxGet("/:owner/:repository/pull/:id/mergeguide")(referrersOnly { repository =>
     params("id").toIntOpt.flatMap{ issueId =>
       val owner = repository.owner
       val name  = repository.name
       getPullRequest(owner, name, issueId) map { case(issue, pullreq) =>
-        val statuses = getCommitStatues(owner, name, pullreq.commitIdTo)
-        val hasConfrict = LockUtil.lock(s"${owner}/${name}"){
+        val hasConflict = LockUtil.lock(s"${owner}/${name}"){
           checkConflict(owner, name, pullreq.branch, issueId)
         }
-        val hasProblem = hasConfrict || (!statuses.isEmpty && CommitState.combine(statuses.map(_.state).toSet) != CommitState.SUCCESS)
+        val hasMergePermission = hasWritePermission(owner, name, context.loginAccount)
+        val branchProtection = getProtectedBranchInfo(owner, name, pullreq.branch)
+        val mergeStatus = PullRequestService.MergeStatus(
+           hasConflict         = hasConflict,
+           commitStatues       = getCommitStatues(owner, name, pullreq.commitIdTo),
+           branchProtection    = branchProtection,
+           branchIsOutOfDate   = JGitUtil.getShaByRef(owner, name, pullreq.branch) != Some(pullreq.commitIdFrom),
+           needStatusCheck     = context.loginAccount.map{ u =>
+                                   branchProtection.needStatusCheck(u.userName)
+                                 }.getOrElse(true),
+           hasUpdatePermission = hasWritePermission(pullreq.requestUserName, pullreq.requestRepositoryName, context.loginAccount) &&
+                                   context.loginAccount.map{ u =>
+                                     !getProtectedBranchInfo(pullreq.requestUserName, pullreq.requestRepositoryName, pullreq.requestBranch).needStatusCheck(u.userName)
+                                   }.getOrElse(false),
+           hasMergePermission  = hasMergePermission,
+           commitIdTo          = pullreq.commitIdTo)
         html.mergeguide(
-          hasConfrict,
-          hasProblem,
+          mergeStatus,
           issue,
           pullreq,
-          statuses,
           repository,
-          getRepository(pullreq.requestUserName, pullreq.requestRepositoryName, context.baseUrl).get)
+          getRepository(pullreq.requestUserName, pullreq.requestRepositoryName).get)
       }
     } getOrElse NotFound
   })
@@ -203,6 +156,75 @@ trait PullRequestsControllerBase extends ControllerBase {
     } getOrElse NotFound
   })
 
+  post("/:owner/:repository/pull/:id/update_branch")(referrersOnly { baseRepository =>
+    (for {
+      issueId <- params("id").toIntOpt
+      loginAccount <- context.loginAccount
+      (issue, pullreq) <- getPullRequest(baseRepository.owner, baseRepository.name, issueId)
+      owner = pullreq.requestUserName
+      name  = pullreq.requestRepositoryName
+      if hasWritePermission(owner, name, context.loginAccount)
+    } yield {
+      val branchProtection = getProtectedBranchInfo(owner, name, pullreq.requestBranch)
+      if(branchProtection.needStatusCheck(loginAccount.userName)){
+        flash += "error" -> s"branch ${pullreq.requestBranch} is protected need status check."
+      } else {
+        val repository = getRepository(owner, name).get
+        LockUtil.lock(s"${owner}/${name}"){
+          val alias = if(pullreq.repositoryName == pullreq.requestRepositoryName && pullreq.userName == pullreq.requestUserName){
+            pullreq.branch
+          }else{
+            s"${pullreq.userName}:${pullreq.branch}"
+          }
+          val existIds = using(Git.open(Directory.getRepositoryDir(owner, name))) { git => JGitUtil.getAllCommitIds(git) }.toSet
+          pullRemote(owner, name, pullreq.requestBranch, pullreq.userName, pullreq.repositoryName, pullreq.branch, loginAccount,
+                     s"Merge branch '${alias}' into ${pullreq.requestBranch}") match {
+            case None => // conflict
+              flash += "error" -> s"Can't automatic merging branch '${alias}' into ${pullreq.requestBranch}."
+            case Some(oldId) =>
+              // update pull request
+              updatePullRequests(owner, name, pullreq.requestBranch)
+
+              using(Git.open(Directory.getRepositoryDir(owner, name))) { git =>
+                //  after update branch
+
+                val newCommitId = git.getRepository.resolve(s"refs/heads/${pullreq.requestBranch}")
+                val commits = git.log.addRange(oldId, newCommitId).call.iterator.asScala.map(c => new JGitUtil.CommitInfo(c)).toList
+
+                commits.foreach{ commit =>
+                  if(!existIds.contains(commit.id)){
+                    createIssueComment(owner, name, commit)
+                  }
+                }
+
+                // record activity
+                recordPushActivity(owner, name, loginAccount.userName, pullreq.branch, commits)
+
+                // close issue by commit message
+                if(pullreq.requestBranch == repository.repository.defaultBranch){
+                  commits.map{ commit =>
+                    closeIssuesFromMessage(commit.fullMessage, loginAccount.userName, owner, name)
+                  }
+                }
+
+                // call web hook
+                callPullRequestWebHookByRequestBranch("synchronize", repository, pullreq.requestBranch, baseUrl, loginAccount)
+                callWebHookOf(owner, name, WebHook.Push) {
+                  for {
+                    ownerAccount <- getAccountByUserName(owner)
+                  } yield {
+                    WebHookService.WebHookPushPayload(git, loginAccount, pullreq.requestBranch, repository, commits, ownerAccount, oldId = oldId, newId = newCommitId)
+                  }
+                }
+              }
+              flash += "info" -> s"Merge branch '${alias}' into ${pullreq.requestBranch}"
+          }
+        }
+        redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}")
+      }
+    }) getOrElse NotFound
+  })
+
   post("/:owner/:repository/pull/:id/merge", mergeForm)(collaboratorsOnly { (form, repository) =>
     params("id").toIntOpt.flatMap { issueId =>
       val owner = repository.owner
@@ -228,7 +250,7 @@ trait PullRequestsControllerBase extends ControllerBase {
               pullreq.requestUserName, pullreq.requestRepositoryName, pullreq.commitIdTo)
 
             // close issue by content of pull request
-            val defaultBranch = getRepository(owner, name, context.baseUrl).get.repository.defaultBranch
+            val defaultBranch = getRepository(owner, name).get.repository.defaultBranch
             if(pullreq.branch == defaultBranch){
               commits.flatten.foreach { commit =>
                 closeIssuesFromMessage(commit.fullMessage, loginAccount.userName, owner, name)
@@ -261,7 +283,7 @@ trait PullRequestsControllerBase extends ControllerBase {
     val headBranch:Option[String] = params.get("head")
     (forkedRepository.repository.originUserName, forkedRepository.repository.originRepositoryName) match {
       case (Some(originUserName), Some(originRepositoryName)) => {
-        getRepository(originUserName, originRepositoryName, context.baseUrl).map { originRepository =>
+        getRepository(originUserName, originRepositoryName).map { originRepository =>
           using(
             Git.open(getRepositoryDir(originUserName, originRepositoryName)),
             Git.open(getRepositoryDir(forkedRepository.owner, forkedRepository.name))
@@ -302,12 +324,12 @@ trait PullRequestsControllerBase extends ControllerBase {
         forkedRepository.repository.originRepositoryName
       } else {
         // Sibling repository
-        getUserRepositories(originOwner, context.baseUrl).find { x =>
+        getUserRepositories(originOwner).find { x =>
           x.repository.originUserName == forkedRepository.repository.originUserName &&
             x.repository.originRepositoryName == forkedRepository.repository.originRepositoryName
         }.map(_.repository.repositoryName)
       };
-      originRepository <- getRepository(originOwner, originRepositoryName, context.baseUrl)
+      originRepository <- getRepository(originOwner, originRepositoryName)
     ) yield {
       using(
         Git.open(getRepositoryDir(originRepository.owner, originRepository.name)),
@@ -375,7 +397,7 @@ trait PullRequestsControllerBase extends ControllerBase {
           getForkedRepositories(forkedRepository.owner, forkedRepository.name).find(_._1 == originOwner).map(_._2)
         }
       };
-      originRepository <- getRepository(originOwner, originRepositoryName, context.baseUrl)
+      originRepository <- getRepository(originOwner, originRepositoryName)
     ) yield {
       using(
         Git.open(getRepositoryDir(originRepository.owner, originRepository.name)),
@@ -441,7 +463,7 @@ trait PullRequestsControllerBase extends ControllerBase {
 
       getIssue(owner, name, issueId.toString) foreach { issue =>
         // extract references and create refer comment
-        createReferComment(owner, name, issue, form.title + " " + form.content.getOrElse(""))
+        createReferComment(owner, name, issue, form.title + " " + form.content.getOrElse(""), context.loginAccount.get)
 
         // notifications
         Notifier().toNotify(repository, issue, form.content.getOrElse("")){
@@ -453,19 +475,6 @@ trait PullRequestsControllerBase extends ControllerBase {
     }
   })
 
-  // TODO Same method exists in IssueController. Should it moved to IssueService?
-  private def createReferComment(owner: String, repository: String, fromIssue: Issue, message: String) = {
-    StringUtil.extractIssueId(message).foreach { issueId =>
-      val content = fromIssue.issueId + ":" + fromIssue.title
-      if(getIssue(owner, repository, issueId).isDefined){
-        // Not add if refer comment already exist.
-        if(!getComments(owner, repository, issueId.toInt).exists { x => x.action == "refer" && x.content == content }) {
-          createComment(owner, repository, context.loginAccount.get.userName, issueId.toInt, content, "refer")
-        }
-      }
-    }
-  }
-
   /**
    * Parses branch identifier and extracts owner and branch name as tuple.
    *
@@ -528,4 +537,5 @@ trait PullRequestsControllerBase extends ControllerBase {
         repository,
         hasWritePermission(owner, repoName, context.loginAccount))
     }
+
 }

src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala

@@ -2,39 +2,46 @@ package gitbucket.core.controller
 
 import gitbucket.core.settings.html
 import gitbucket.core.model.WebHook
-import gitbucket.core.service.{RepositoryService, AccountService, WebHookService}
+import gitbucket.core.service.{RepositoryService, AccountService, WebHookService, ProtectedBranchService, CommitStatusService}
 import gitbucket.core.service.WebHookService._
 import gitbucket.core.util._
 import gitbucket.core.util.JGitUtil._
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util.Directory._
-import jp.sf.amateras.scalatra.forms._
+import io.github.gitbucket.scalatra.forms._
 import org.apache.commons.io.FileUtils
 import org.scalatra.i18n.Messages
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.lib.Constants
 import org.eclipse.jgit.lib.ObjectId
+import gitbucket.core.model.WebHookContentType
 
 
 class RepositorySettingsController extends RepositorySettingsControllerBase
-  with RepositoryService with AccountService with WebHookService
+  with RepositoryService with AccountService with WebHookService with ProtectedBranchService with CommitStatusService
   with OwnerAuthenticator with UsersAuthenticator
 
 trait RepositorySettingsControllerBase extends ControllerBase {
-  self: RepositoryService with AccountService with WebHookService
+  self: RepositoryService with AccountService with WebHookService with ProtectedBranchService with CommitStatusService
     with OwnerAuthenticator with UsersAuthenticator =>
 
   // for repository options
-  case class OptionsForm(repositoryName: String, description: Option[String], defaultBranch: String, isPrivate: Boolean)
+  case class OptionsForm(repositoryName: String, description: Option[String], isPrivate: Boolean)
   
   val optionsForm = mapping(
     "repositoryName" -> trim(label("Repository Name", text(required, maxlength(40), identifier, renameRepositoryName))),
     "description"    -> trim(label("Description"    , optional(text()))),
-    "defaultBranch"  -> trim(label("Default Branch" , text(required, maxlength(100)))),
     "isPrivate"      -> trim(label("Repository Type", boolean()))
   )(OptionsForm.apply)
 
+  // for default branch
+  case class DefaultBranchForm(defaultBranch: String)
+
+  val defaultBranchForm = mapping(
+    "defaultBranch"  -> trim(label("Default Branch" , text(required, maxlength(100))))
+  )(DefaultBranchForm.apply)
+
   // for collaborator addition
   case class CollaboratorForm(userName: String)
 
@@ -43,12 +50,16 @@ trait RepositorySettingsControllerBase extends ControllerBase {
   )(CollaboratorForm.apply)
 
   // for web hook url addition
-  case class WebHookForm(url: String, events: Set[WebHook.Event])
+  case class WebHookForm(url: String, events: Set[WebHook.Event], ctype: WebHookContentType, token: Option[String])
 
   def webHookForm(update:Boolean) = mapping(
     "url"    -> trim(label("url", text(required, webHook(update)))),
-    "events" -> webhookEvents
-  )(WebHookForm.apply)
+    "events" -> webhookEvents,
+    "ctype" -> label("ctype", text()),
+    "token" -> optional(trim(label("token", text(maxlength(100)))))
+  )(
+    (url, events, ctype, token) => WebHookForm(url, events, WebHookContentType.valueOf(ctype), token)
+  )
 
   // for transfer ownership
   case class TransferOwnerShipForm(newOwner: String)
@@ -75,12 +86,10 @@ trait RepositorySettingsControllerBase extends ControllerBase {
    * Save the repository options.
    */
   post("/:owner/:repository/settings/options", optionsForm)(ownerOnly { (form, repository) =>
-    val defaultBranch = if(repository.branchList.isEmpty) "master" else form.defaultBranch
     saveRepositoryOptions(
       repository.owner,
       repository.name,
       form.description,
-      defaultBranch,
       repository.repository.parentUserName.map { _ =>
         repository.repository.isPrivate
       } getOrElse form.isPrivate
@@ -98,14 +107,45 @@ trait RepositorySettingsControllerBase extends ControllerBase {
         FileUtils.moveDirectory(dir, getWikiRepositoryDir(repository.owner, form.repositoryName))
       }
     }
-    // Change repository HEAD
-    using(Git.open(getRepositoryDir(repository.owner, form.repositoryName))) { git =>
-      git.getRepository.updateRef(Constants.HEAD, true).link(Constants.R_HEADS + defaultBranch)
-    }
     flash += "info" -> "Repository settings has been updated."
     redirect(s"/${repository.owner}/${form.repositoryName}/settings/options")
   })
-  
+
+  /** branch settings */
+  get("/:owner/:repository/settings/branches")(ownerOnly { repository =>
+    val protecteions = getProtectedBranchList(repository.owner, repository.name)
+    html.branches(repository, protecteions, flash.get("info"))
+  });
+
+  /** Update default branch */
+  post("/:owner/:repository/settings/update_default_branch", defaultBranchForm)(ownerOnly { (form, repository) =>
+    if(repository.branchList.find(_ == form.defaultBranch).isEmpty){
+      redirect(s"/${repository.owner}/${repository.name}/settings/options")
+    } else {
+      saveRepositoryDefaultBranch(repository.owner, repository.name, form.defaultBranch)
+      // Change repository HEAD
+      using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+        git.getRepository.updateRef(Constants.HEAD, true).link(Constants.R_HEADS + form.defaultBranch)
+      }
+      flash += "info" -> "Repository default branch has been updated."
+      redirect(s"/${repository.owner}/${repository.name}/settings/branches")
+    }
+  })
+
+  /** Branch protection for branch */
+  get("/:owner/:repository/settings/branches/:branch")(ownerOnly { repository =>
+    import gitbucket.core.api._
+    val branch = params("branch")
+    if(repository.branchList.find(_ == branch).isEmpty){
+      redirect(s"/${repository.owner}/${repository.name}/settings/branches")
+    } else {
+      val protection = ApiBranchProtection(getProtectedBranchInfo(repository.owner, repository.name, branch))
+      val lastWeeks = getRecentStatuesContexts(repository.owner, repository.name, org.joda.time.LocalDateTime.now.minusWeeks(1).toDate).toSet
+      val knownContexts = (lastWeeks ++ protection.status.contexts).toSeq.sortBy(identity)
+      html.branchprotection(repository, branch, protection, knownContexts, flash.get("info"))
+    }
+  })
+
   /**
    * Display the Collaborators page.
    */
@@ -147,7 +187,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
    * Display the web hook edit page.
    */
   get("/:owner/:repository/settings/hooks/new")(ownerOnly { repository =>
-    val webhook = WebHook(repository.owner, repository.name, "")
+    val webhook = WebHook(repository.owner, repository.name, "", WebHookContentType.FORM, None)
     html.edithooks(webhook, Set(WebHook.Push), repository, flash.get("info"), true)
   })
 
@@ -155,7 +195,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
    * Add the web hook URL.
    */
   post("/:owner/:repository/settings/hooks/new", webHookForm(false))(ownerOnly { (form, repository) =>
-    addWebHook(repository.owner, repository.name, form.url, form.events)
+    addWebHook(repository.owner, repository.name, form.url, form.events, form.ctype, form.token)
     flash += "info" -> s"Webhook ${form.url} created"
     redirect(s"/${repository.owner}/${repository.name}/settings/hooks")
   })
@@ -184,7 +224,9 @@ trait RepositorySettingsControllerBase extends ControllerBase {
       import scala.concurrent.ExecutionContext.Implicits.global
 
       val url = params("url")
-      val dummyWebHookInfo = WebHook(repository.owner, repository.name, url)
+      val token = Some(params("token"))
+      val ctype = WebHookContentType.valueOf(params("ctype"))
+      val dummyWebHookInfo = WebHook(repository.owner, repository.name, url, ctype, token)
       val dummyPayload = {
         val ownerAccount = getAccountByUserName(repository.owner).get
         val commits = if(repository.commitCount == 0) List.empty else git.log
@@ -243,7 +285,7 @@ trait RepositorySettingsControllerBase extends ControllerBase {
    * Update web hook settings.
    */
   post("/:owner/:repository/settings/hooks/edit", webHookForm(true))(ownerOnly { (form, repository) =>
-    updateWebHook(repository.owner, repository.name, form.url, form.events)
+    updateWebHook(repository.owner, repository.name, form.url, form.events, form.ctype, form.token)
     flash += "info" -> s"webhook ${form.url} updated"
     redirect(s"/${repository.owner}/${repository.name}/settings/hooks")
   })

src/main/scala/gitbucket/core/controller/RepositoryViewerController.scala

@@ -2,7 +2,6 @@ package gitbucket.core.controller
 
 import javax.servlet.http.{HttpServletResponse, HttpServletRequest}
 
-import gitbucket.core.api._
 import gitbucket.core.plugin.PluginRegistry
 import gitbucket.core.repo.html
 import gitbucket.core.helper
@@ -13,13 +12,12 @@ import gitbucket.core.util.StringUtil._
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util.Directory._
-import gitbucket.core.model.{Account, CommitState, WebHook}
-import gitbucket.core.service.CommitStatusService
+import gitbucket.core.model.{Account, WebHook}
 import gitbucket.core.service.WebHookService._
 import gitbucket.core.view
 import gitbucket.core.view.helpers
 
-import jp.sf.amateras.scalatra.forms._
+import io.github.gitbucket.scalatra.forms._
 import org.apache.commons.io.FileUtils
 import org.eclipse.jgit.api.{ArchiveCommand, Git}
 import org.eclipse.jgit.archive.{TgzFormat, ZipFormat}
@@ -34,7 +32,7 @@ import org.scalatra._
 class RepositoryViewerController extends RepositoryViewerControllerBase
   with RepositoryService with AccountService with ActivityService with IssuesService with WebHookService with CommitsService
   with ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator with PullRequestService with CommitStatusService
-  with WebHookPullRequestService with WebHookPullRequestReviewCommentService
+  with WebHookPullRequestService with WebHookPullRequestReviewCommentService with ProtectedBranchService
 
 /**
  * The repository viewer.
@@ -42,7 +40,7 @@ class RepositoryViewerController extends RepositoryViewerControllerBase
 trait RepositoryViewerControllerBase extends ControllerBase {
   self: RepositoryService with AccountService with ActivityService with IssuesService with WebHookService with CommitsService
     with ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator with PullRequestService with CommitStatusService
-    with WebHookPullRequestService with WebHookPullRequestReviewCommentService =>
+    with WebHookPullRequestService with WebHookPullRequestReviewCommentService with ProtectedBranchService =>
 
   ArchiveCommand.registerFormat("zip", new ZipFormat)
   ArchiveCommand.registerFormat("tar.gz", new TgzFormat)
@@ -111,6 +109,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
       enableRefsLink = params("enableRefsLink").toBoolean,
       enableLineBreaks = params("enableLineBreaks").toBoolean,
       enableTaskList = params("enableTaskList").toBoolean,
+      enableAnchor = false,
       hasWritePermission = hasWritePermission(repository.owner, repository.name, context.loginAccount)
     )
   })
@@ -122,13 +121,6 @@ trait RepositoryViewerControllerBase extends ControllerBase {
     fileList(_)
   })
 
-  /**
-   * https://developer.github.com/v3/repos/#get
-   */
-  get("/api/v3/repos/:owner/:repository")(referrersOnly { repository =>
-    JsonFormat(ApiRepository(repository, ApiUser(getAccountByUserName(repository.owner).get)))
-  })
-
   /**
    * Displays the file list of the specified path and branch.
    */
@@ -160,73 +152,17 @@ trait RepositoryViewerControllerBase extends ControllerBase {
     }
   })
 
-  /**
-   * https://developer.github.com/v3/repos/statuses/#create-a-status
-   */
-  post("/api/v3/repos/:owner/:repo/statuses/:sha")(collaboratorsOnly { repository =>
-    (for{
-      ref <- params.get("sha")
-      sha <- JGitUtil.getShaByRef(repository.owner, repository.name, ref)
-      data <- extractFromJsonBody[CreateAStatus] if data.isValid
-      creator <- context.loginAccount
-      state <- CommitState.valueOf(data.state)
-      statusId = createCommitStatus(repository.owner, repository.name, sha, data.context.getOrElse("default"),
-                                    state, data.target_url, data.description, new java.util.Date(), creator)
-      status <- getCommitStatus(repository.owner, repository.name, statusId)
-    } yield {
-      JsonFormat(ApiCommitStatus(status, ApiUser(creator)))
-    }) getOrElse NotFound
-  })
-
-  /**
-   * https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref
-   *
-   * ref is Ref to list the statuses from. It can be a SHA, a branch name, or a tag name.
-   */
-  val listStatusesRoute = get("/api/v3/repos/:owner/:repo/commits/:ref/statuses")(referrersOnly { repository =>
-    (for{
-      ref <- params.get("ref")
-      sha <- JGitUtil.getShaByRef(repository.owner, repository.name, ref)
-    } yield {
-      JsonFormat(getCommitStatuesWithCreator(repository.owner, repository.name, sha).map{ case(status, creator) =>
-        ApiCommitStatus(status, ApiUser(creator))
-      })
-    }) getOrElse NotFound
-  })
-
-  /**
-   * https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref
-   *
-   * legacy route
-   */
-  get("/api/v3/repos/:owner/:repo/statuses/:ref"){
-    listStatusesRoute.action()
-  }
-
-  /**
-   * https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref
-   *
-   * ref is Ref to list the statuses from. It can be a SHA, a branch name, or a tag name.
-   */
-  get("/api/v3/repos/:owner/:repo/commits/:ref/status")(referrersOnly { repository =>
-    (for{
-      ref <- params.get("ref")
-      owner <- getAccountByUserName(repository.owner)
-      sha <- JGitUtil.getShaByRef(repository.owner, repository.name, ref)
-    } yield {
-      val statuses = getCommitStatuesWithCreator(repository.owner, repository.name, sha)
-      JsonFormat(ApiCombinedCommitStatus(sha, statuses, ApiRepository(repository, owner)))
-    }) getOrElse NotFound
-  })
-
   get("/:owner/:repository/new/*")(collaboratorsOnly { repository =>
     val (branch, path) = splitPath(repository, multiParams("splat").head)
+    val protectedBranch = getProtectedBranchInfo(repository.owner, repository.name, branch).needStatusCheck(context.loginAccount.get.userName)
     html.editor(branch, repository, if(path.length == 0) Nil else path.split("/").toList,
-      None, JGitUtil.ContentInfo("text", None, Some("UTF-8")))
+      None, JGitUtil.ContentInfo("text", None, Some("UTF-8")),
+      protectedBranch)
   })
 
   get("/:owner/:repository/edit/*")(collaboratorsOnly { repository =>
     val (branch, path) = splitPath(repository, multiParams("splat").head)
+    val protectedBranch = getProtectedBranchInfo(repository.owner, repository.name, branch).needStatusCheck(context.loginAccount.get.userName)
 
     using(Git.open(getRepositoryDir(repository.owner, repository.name))){ git =>
       val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(branch))
@@ -234,7 +170,8 @@ trait RepositoryViewerControllerBase extends ControllerBase {
       getPathObjectId(git, path, revCommit).map { objectId =>
         val paths = path.split("/")
         html.editor(branch, repository, paths.take(paths.size - 1).toList, Some(paths.last),
-          JGitUtil.getContentInfo(git, path, objectId))
+          JGitUtil.getContentInfo(git, path, objectId),
+          protectedBranch)
       } getOrElse NotFound
     }
   })
@@ -303,7 +240,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
       val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))
       getPathObjectId(git, path, revCommit).flatMap { objectId =>
         JGitUtil.getObjectLoaderFromId(git, objectId){ loader =>
-          contentType = "application/octet-stream"
+          contentType = FileUtil.getMimeType(path)
           response.setContentLength(loader.getSize.toInt)
           loader.copyTo(response.outputStream)
           ()
@@ -324,7 +261,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
         if(raw){
           // Download (This route is left for backword compatibility)
           JGitUtil.getObjectLoaderFromId(git, objectId){ loader =>
-            contentType = "application/octet-stream"
+            contentType = FileUtil.getMimeType(path)
             response.setContentLength(loader.getSize.toInt)
             loader.copyTo(response.outputStream)
             ()
@@ -485,6 +422,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
    * Displays branches.
    */
   get("/:owner/:repository/branches")(referrersOnly { repository =>
+    val protectedBranches = getProtectedBranchList(repository.owner, repository.name).toSet
     val branches = JGitUtil.getBranches(
       owner         = repository.owner,
       name          = repository.name,
@@ -492,7 +430,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
       origin        = repository.repository.originUserName.isEmpty
     )
     .sortBy(br => (br.mergeInfo.isEmpty, br.commitTime))
-    .map(br => br -> getPullRequestByRequestCommit(repository.owner, repository.name, repository.repository.defaultBranch, br.name, br.commitId))
+    .map(br => (br, getPullRequestByRequestCommit(repository.owner, repository.name, repository.repository.defaultBranch, br.name, br.commitId), protectedBranches.contains(br.name)))
     .reverse
 
     html.branches(branches, hasWritePermission(repository.owner, repository.name, context.loginAccount), repository)
@@ -555,11 +493,14 @@ trait RepositoryViewerControllerBase extends ControllerBase {
     html.forked(
       getRepository(
         repository.repository.originUserName.getOrElse(repository.owner),
-        repository.repository.originRepositoryName.getOrElse(repository.name),
-        context.baseUrl),
+        repository.repository.originRepositoryName.getOrElse(repository.name)),
       getForkedRepositories(
         repository.repository.originUserName.getOrElse(repository.owner),
         repository.repository.originRepositoryName.getOrElse(repository.name)),
+      context.loginAccount match {
+        case None => List()
+        case account: Option[Account] => getGroupsByUserName(account.get.userName)
+      }, // groups of current user
       repository)
   })
 
@@ -570,13 +511,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
     using(Git.open(getRepositoryDir(repository.owner, repository.name))){ git =>
       val ref = multiParams("splat").head
       JGitUtil.getTreeId(git, ref).map{ treeId =>
-        html.find(ref,
-                  treeId,
-                  repository,
-                  context.loginAccount match {
-                    case None => List()
-                    case account: Option[Account] => getGroupsByUserName(account.get.userName)
-                  })
+        html.find(ref, treeId, repository)
       } getOrElse NotFound
     }
   })
@@ -629,7 +564,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
             val parentPath = if (path == ".") Nil else path.split("/").toList
             // process README.md or README.markdown
             val readme = files.find { file =>
-              readmeFiles.contains(file.name.toLowerCase)
+              !file.isDirectory && readmeFiles.contains(file.name.toLowerCase)
             }.map { file =>
               val path = (file.name :: parentPath.reverse).reverse
               path -> StringUtil.convertFromByteArray(JGitUtil.getContentFromId(
@@ -638,10 +573,6 @@ trait RepositoryViewerControllerBase extends ControllerBase {
 
             html.files(revision, repository,
               if(path == ".") Nil else path.split("/").toList, // current path
-              context.loginAccount match {
-                case None => List()
-                case account: Option[Account] => getGroupsByUserName(account.get.userName)
-              }, // groups of current user
               new JGitUtil.CommitInfo(lastModifiedCommit), // last modified commit
               files, readme, hasWritePermission(repository.owner, repository.name, context.loginAccount),
               getPullRequestFromBranch(repository.owner, repository.name, revstr, repository.repository.defaultBranch),
@@ -683,7 +614,7 @@ trait RepositoryViewerControllerBase extends ControllerBase {
           headName, loginAccount.fullName, loginAccount.mailAddress, message)
 
         inserter.flush()
-        inserter.release()
+        inserter.close()
 
         // update refs
         val refUpdate = git.getRepository.updateRef(headName)
@@ -754,8 +685,6 @@ trait RepositoryViewerControllerBase extends ControllerBase {
          .setTree(revCommit.getTree)
          .setOutputStream(response.getOutputStream)
          .call()
-
-      Unit
     }
   }
 

src/main/scala/gitbucket/core/controller/SearchController.scala

@@ -1,51 +0,0 @@
-package gitbucket.core.controller
-
-import gitbucket.core.search.html
-import gitbucket.core.service._
-import gitbucket.core.util.{StringUtil, ControlUtil, ReferrerAuthenticator, Implicits}
-import ControlUtil._
-import Implicits._
-import jp.sf.amateras.scalatra.forms._
-
-class SearchController extends SearchControllerBase
-  with RepositoryService with AccountService with ActivityService with RepositorySearchService with IssuesService with ReferrerAuthenticator
-
-trait SearchControllerBase extends ControllerBase { self: RepositoryService
-  with ActivityService with RepositorySearchService with ReferrerAuthenticator =>
-
-  val searchForm = mapping(
-    "query"      -> trim(text(required)),
-    "owner"      -> trim(text(required)),
-    "repository" -> trim(text(required))
-  )(SearchForm.apply)
-
-  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)}")
-  }
-
-  get("/:owner/:repository/search")(referrersOnly { repository =>
-    defining(params("q").trim, params.getOrElse("type", "code")){ case (query, target) =>
-      val page   = try {
-        val i = params.getOrElse("page", "1").toInt
-        if(i <= 0) 1 else i
-      } catch {
-        case e: NumberFormatException => 1
-      }
-
-      target.toLowerCase match {
-        case "issue" => html.issues(
-          searchIssues(repository.owner, repository.name, query),
-          countFiles(repository.owner, repository.name, query),
-          query, page, repository)
-
-        case _ => html.code(
-          searchFiles(repository.owner, repository.name, query),
-          countIssues(repository.owner, repository.name, query),
-          query, page, repository)
-      }
-    }
-  })
-
-}

src/main/scala/gitbucket/core/controller/SystemSettingsController.scala

@@ -1,17 +1,24 @@
 package gitbucket.core.controller
 
 import gitbucket.core.admin.html
-import gitbucket.core.service.{AccountService, SystemSettingsService}
+import gitbucket.core.service.{AccountService, SystemSettingsService, RepositoryService}
 import gitbucket.core.util.AdminAuthenticator
 import gitbucket.core.ssh.SshServer
+import gitbucket.core.plugin.PluginRegistry
 import SystemSettingsService._
-import jp.sf.amateras.scalatra.forms._
+import gitbucket.core.util.Implicits._
+import gitbucket.core.util.ControlUtil._
+import gitbucket.core.util.Directory._
+import gitbucket.core.util.StringUtil._
+import io.github.gitbucket.scalatra.forms._
+import org.apache.commons.io.FileUtils
+import org.scalatra.i18n.Messages
 
 class SystemSettingsController extends SystemSettingsControllerBase
-  with AccountService with AdminAuthenticator
+  with AccountService with RepositoryService with AdminAuthenticator
 
-trait SystemSettingsControllerBase extends ControllerBase {
-  self: AccountService with AdminAuthenticator =>
+trait SystemSettingsControllerBase extends AccountManagementControllerBase {
+  self: AccountService with RepositoryService with AdminAuthenticator =>
 
   private val form = mapping(
     "baseUrl"                  -> trim(label("Base URL", optional(text()))),
@@ -23,6 +30,7 @@ trait SystemSettingsControllerBase extends ControllerBase {
     "notification"             -> trim(label("Notification", boolean())),
     "activityLogLimit"         -> trim(label("Limit of activity logs", optional(number()))),
     "ssh"                      -> trim(label("SSH access", boolean())),
+    "sshHost"                  -> trim(label("SSH host", optional(text()))),
     "sshPort"                  -> trim(label("SSH port", optional(number()))),
     "useSMTP"                  -> trim(label("SMTP", boolean())),
     "smtp"                     -> optionalIfNotChecked("useSMTP", mapping(
@@ -50,9 +58,14 @@ trait SystemSettingsControllerBase extends ControllerBase {
         "keystore"                 -> trim(label("Keystore", optional(text())))
     )(Ldap.apply))
   )(SystemSettings.apply).verifying { settings =>
-    if(settings.ssh && settings.baseUrl.isEmpty){
-      Seq("baseUrl" -> "Base URL is required if SSH access is enabled.")
-    } else Nil
+    Vector(
+      if(settings.ssh && settings.baseUrl.isEmpty){
+        Some("baseUrl" -> "Base URL is required if SSH access is enabled.")
+      } else None,
+      if(settings.ssh && settings.sshHost.isEmpty){
+        Some("sshHost" -> "SSH host is required if SSH access is enabled.")
+      } else None
+    ).flatten
   }
 
   private val pluginForm = mapping(
@@ -61,6 +74,61 @@ trait SystemSettingsControllerBase extends ControllerBase {
 
   case class PluginForm(pluginIds: List[String])
 
+
+  case class NewUserForm(userName: String, password: String, fullName: String,
+                         mailAddress: String, isAdmin: Boolean,
+                         url: Option[String], fileId: Option[String])
+
+  case class EditUserForm(userName: String, password: Option[String], fullName: String,
+                          mailAddress: String, isAdmin: Boolean, url: Option[String],
+                          fileId: Option[String], clearImage: Boolean, isRemoved: Boolean)
+
+  case class NewGroupForm(groupName: String, url: Option[String], fileId: Option[String],
+                          members: String)
+
+  case class EditGroupForm(groupName: String, url: Option[String], fileId: Option[String],
+                           members: String, clearImage: Boolean, isRemoved: Boolean)
+
+
+  val newUserForm = mapping(
+    "userName"    -> trim(label("Username"     ,text(required, maxlength(100), identifier, uniqueUserName))),
+    "password"    -> trim(label("Password"     ,text(required, maxlength(20)))),
+    "fullName"    -> trim(label("Full Name"    ,text(required, maxlength(100)))),
+    "mailAddress" -> trim(label("Mail Address" ,text(required, maxlength(100), uniqueMailAddress()))),
+    "isAdmin"     -> trim(label("User Type"    ,boolean())),
+    "url"         -> trim(label("URL"          ,optional(text(maxlength(200))))),
+    "fileId"      -> trim(label("File ID"      ,optional(text())))
+  )(NewUserForm.apply)
+
+  val editUserForm = mapping(
+    "userName"    -> trim(label("Username"     ,text(required, maxlength(100), identifier))),
+    "password"    -> trim(label("Password"     ,optional(text(maxlength(20))))),
+    "fullName"    -> trim(label("Full Name"    ,text(required, maxlength(100)))),
+    "mailAddress" -> trim(label("Mail Address" ,text(required, maxlength(100), uniqueMailAddress("userName")))),
+    "isAdmin"     -> trim(label("User Type"    ,boolean())),
+    "url"         -> trim(label("URL"          ,optional(text(maxlength(200))))),
+    "fileId"      -> trim(label("File ID"      ,optional(text()))),
+    "clearImage"  -> trim(label("Clear image"  ,boolean())),
+    "removed"     -> trim(label("Disable"      ,boolean(disableByNotYourself("userName"))))
+  )(EditUserForm.apply)
+
+  val newGroupForm = mapping(
+    "groupName" -> trim(label("Group name" ,text(required, maxlength(100), identifier, uniqueUserName))),
+    "url"       -> trim(label("URL"        ,optional(text(maxlength(200))))),
+    "fileId"    -> trim(label("File ID"    ,optional(text()))),
+    "members"   -> trim(label("Members"    ,text(required, members)))
+  )(NewGroupForm.apply)
+
+  val editGroupForm = mapping(
+    "groupName"  -> trim(label("Group name"  ,text(required, maxlength(100), identifier))),
+    "url"        -> trim(label("URL"         ,optional(text(maxlength(200))))),
+    "fileId"     -> trim(label("File ID"     ,optional(text()))),
+    "members"    -> trim(label("Members"     ,text(required, members))),
+    "clearImage" -> trim(label("Clear image" ,boolean())),
+    "removed"    -> trim(label("Disable"     ,boolean()))
+  )(EditGroupForm.apply)
+
+
   get("/admin/system")(adminOnly {
     html.system(flash.get("info"))
   })
@@ -68,20 +136,155 @@ trait SystemSettingsControllerBase extends ControllerBase {
   post("/admin/system", form)(adminOnly { form =>
     saveSystemSettings(form)
 
-    if(form.ssh && SshServer.isActive && context.settings.sshPort != form.sshPort){
-      SshServer.stop()
-    }
-
-    if(form.ssh && !SshServer.isActive && form.baseUrl.isDefined){
-      SshServer.start(
-        form.sshPort.getOrElse(SystemSettingsService.DefaultSshPort),
-        form.baseUrl.get)
-    } else if(!form.ssh && SshServer.isActive){
+    if (form.sshAddress != context.settings.sshAddress) {
       SshServer.stop()
+       for {
+         sshAddress <- form.sshAddress
+         baseUrl    <- form.baseUrl
+       }
+       SshServer.start(sshAddress, baseUrl)
     }
 
     flash += "info" -> "System settings has been updated."
     redirect("/admin/system")
   })
 
+  get("/admin/plugins")(adminOnly {
+    html.plugins(PluginRegistry().getPlugins())
+  })
+
+
+  get("/admin/users")(adminOnly {
+    val includeRemoved = params.get("includeRemoved").map(_.toBoolean).getOrElse(false)
+    val users          = getAllUsers(includeRemoved)
+    val members        = users.collect { case account if(account.isGroupAccount) =>
+      account.userName -> getGroupMembers(account.userName).map(_.userName)
+    }.toMap
+
+    html.userlist(users, members, includeRemoved)
+  })
+
+  get("/admin/users/_newuser")(adminOnly {
+    html.user(None)
+  })
+
+  post("/admin/users/_newuser", newUserForm)(adminOnly { form =>
+    createAccount(form.userName, sha1(form.password), form.fullName, form.mailAddress, form.isAdmin, form.url)
+    updateImage(form.userName, form.fileId, false)
+    redirect("/admin/users")
+  })
+
+  get("/admin/users/:userName/_edituser")(adminOnly {
+    val userName = params("userName")
+    html.user(getAccountByUserName(userName, true))
+  })
+
+  post("/admin/users/:name/_edituser", editUserForm)(adminOnly { form =>
+    val userName = params("userName")
+    getAccountByUserName(userName, true).map { account =>
+
+      if(form.isRemoved){
+        // Remove repositories
+        //        getRepositoryNamesOfUser(userName).foreach { repositoryName =>
+        //          deleteRepository(userName, repositoryName)
+        //          FileUtils.deleteDirectory(getRepositoryDir(userName, repositoryName))
+        //          FileUtils.deleteDirectory(getWikiRepositoryDir(userName, repositoryName))
+        //          FileUtils.deleteDirectory(getTemporaryDir(userName, repositoryName))
+        //        }
+        // Remove from GROUP_MEMBER, COLLABORATOR and REPOSITORY
+        removeUserRelatedData(userName)
+      }
+
+      updateAccount(account.copy(
+        password     = form.password.map(sha1).getOrElse(account.password),
+        fullName     = form.fullName,
+        mailAddress  = form.mailAddress,
+        isAdmin      = form.isAdmin,
+        url          = form.url,
+        isRemoved    = form.isRemoved))
+
+      updateImage(userName, form.fileId, form.clearImage)
+      redirect("/admin/users")
+
+    } getOrElse NotFound
+  })
+
+  get("/admin/users/_newgroup")(adminOnly {
+    html.usergroup(None, Nil)
+  })
+
+  post("/admin/users/_newgroup", newGroupForm)(adminOnly { form =>
+    createGroup(form.groupName, form.url)
+    updateGroupMembers(form.groupName, form.members.split(",").map {
+      _.split(":") match {
+        case Array(userName, isManager) => (userName, isManager.toBoolean)
+      }
+    }.toList)
+    updateImage(form.groupName, form.fileId, false)
+    redirect("/admin/users")
+  })
+
+  get("/admin/users/:groupName/_editgroup")(adminOnly {
+    defining(params("groupName")){ groupName =>
+      html.usergroup(getAccountByUserName(groupName, true), getGroupMembers(groupName))
+    }
+  })
+
+  post("/admin/users/:groupName/_editgroup", editGroupForm)(adminOnly { form =>
+    defining(params("groupName"), form.members.split(",").map {
+      _.split(":") match {
+        case Array(userName, isManager) => (userName, isManager.toBoolean)
+      }
+    }.toList){ case (groupName, members) =>
+      getAccountByUserName(groupName, true).map { account =>
+        updateGroup(groupName, form.url, form.isRemoved)
+
+        if(form.isRemoved){
+          // Remove from GROUP_MEMBER
+          updateGroupMembers(form.groupName, Nil)
+          // Remove repositories
+          getRepositoryNamesOfUser(form.groupName).foreach { repositoryName =>
+            deleteRepository(groupName, repositoryName)
+            FileUtils.deleteDirectory(getRepositoryDir(groupName, repositoryName))
+            FileUtils.deleteDirectory(getWikiRepositoryDir(groupName, repositoryName))
+            FileUtils.deleteDirectory(getTemporaryDir(groupName, repositoryName))
+          }
+        } else {
+          // Update GROUP_MEMBER
+          updateGroupMembers(form.groupName, members)
+          // Update COLLABORATOR for group repositories
+          getRepositoryNamesOfUser(form.groupName).foreach { repositoryName =>
+            removeCollaborators(form.groupName, repositoryName)
+            members.foreach { case (userName, isManager) =>
+              addCollaborator(form.groupName, repositoryName, userName)
+            }
+          }
+        }
+
+        updateImage(form.groupName, form.fileId, form.clearImage)
+        redirect("/admin/users")
+
+      } getOrElse NotFound
+    }
+  })
+
+  private def members: Constraint = new Constraint(){
+    override def validate(name: String, value: String, messages: Messages): Option[String] = {
+      if(value.split(",").exists {
+        _.split(":") match { case Array(userName, isManager) => isManager.toBoolean }
+      }) None else Some("Must select one manager at least.")
+    }
+  }
+
+  protected def disableByNotYourself(paramName: String): Constraint = new Constraint() {
+    override def validate(name: String, value: String, messages: Messages): Option[String] = {
+      params.get(paramName).flatMap { userName =>
+        if(userName == context.loginAccount.get.userName && params.get("removed") == Some("true"))
+          Some("You can't disable your account yourself")
+        else
+          None
+      }
+    }
+  }
+
 }

src/main/scala/gitbucket/core/controller/UserManagementController.scala

@@ -1,204 +0,0 @@
-package gitbucket.core.controller
-
-import gitbucket.core.service.{RepositoryService, AccountService}
-import gitbucket.core.admin.users.html
-import gitbucket.core.util._
-import gitbucket.core.util.ControlUtil._
-import gitbucket.core.util.StringUtil._
-import gitbucket.core.util.Implicits._
-import gitbucket.core.util.Directory._
-import jp.sf.amateras.scalatra.forms._
-import org.scalatra.i18n.Messages
-import org.apache.commons.io.FileUtils
-
-class UserManagementController extends UserManagementControllerBase
-  with AccountService with RepositoryService with AdminAuthenticator
-
-trait UserManagementControllerBase extends AccountManagementControllerBase {
-  self: AccountService with RepositoryService with AdminAuthenticator =>
-  
-  case class NewUserForm(userName: String, password: String, fullName: String,
-                         mailAddress: String, isAdmin: Boolean,
-                         url: Option[String], fileId: Option[String])
-
-  case class EditUserForm(userName: String, password: Option[String], fullName: String,
-                          mailAddress: String, isAdmin: Boolean, url: Option[String],
-                          fileId: Option[String], clearImage: Boolean, isRemoved: Boolean)
-
-  case class NewGroupForm(groupName: String, url: Option[String], fileId: Option[String],
-                          members: String)
-
-  case class EditGroupForm(groupName: String, url: Option[String], fileId: Option[String],
-                           members: String, clearImage: Boolean, isRemoved: Boolean)
-
-  val newUserForm = mapping(
-    "userName"    -> trim(label("Username"     ,text(required, maxlength(100), identifier, uniqueUserName))),
-    "password"    -> trim(label("Password"     ,text(required, maxlength(20)))),
-    "fullName"    -> trim(label("Full Name"    ,text(required, maxlength(100)))),
-    "mailAddress" -> trim(label("Mail Address" ,text(required, maxlength(100), uniqueMailAddress()))),
-    "isAdmin"     -> trim(label("User Type"    ,boolean())),
-    "url"         -> trim(label("URL"          ,optional(text(maxlength(200))))),
-    "fileId"      -> trim(label("File ID"      ,optional(text())))
-  )(NewUserForm.apply)
-
-  val editUserForm = mapping(
-    "userName"    -> trim(label("Username"     ,text(required, maxlength(100), identifier))),
-    "password"    -> trim(label("Password"     ,optional(text(maxlength(20))))),
-    "fullName"    -> trim(label("Full Name"    ,text(required, maxlength(100)))),
-    "mailAddress" -> trim(label("Mail Address" ,text(required, maxlength(100), uniqueMailAddress("userName")))),
-    "isAdmin"     -> trim(label("User Type"    ,boolean())),
-    "url"         -> trim(label("URL"          ,optional(text(maxlength(200))))),
-    "fileId"      -> trim(label("File ID"      ,optional(text()))),
-    "clearImage"  -> trim(label("Clear image"  ,boolean())),
-    "removed"     -> trim(label("Disable"      ,boolean(disableByNotYourself("userName"))))
-  )(EditUserForm.apply)
-
-  val newGroupForm = mapping(
-    "groupName" -> trim(label("Group name" ,text(required, maxlength(100), identifier, uniqueUserName))),
-    "url"       -> trim(label("URL"        ,optional(text(maxlength(200))))),
-    "fileId"    -> trim(label("File ID"    ,optional(text()))),
-    "members"   -> trim(label("Members"    ,text(required, members)))
-  )(NewGroupForm.apply)
-
-  val editGroupForm = mapping(
-    "groupName"  -> trim(label("Group name"  ,text(required, maxlength(100), identifier))),
-    "url"        -> trim(label("URL"         ,optional(text(maxlength(200))))),
-    "fileId"     -> trim(label("File ID"     ,optional(text()))),
-    "members"    -> trim(label("Members"     ,text(required, members))),
-    "clearImage" -> trim(label("Clear image" ,boolean())),
-    "removed"    -> trim(label("Disable"     ,boolean()))
-  )(EditGroupForm.apply)
-
-  get("/admin/users")(adminOnly {
-    val includeRemoved = params.get("includeRemoved").map(_.toBoolean).getOrElse(false)
-    val users          = getAllUsers(includeRemoved)
-    val members        = users.collect { case account if(account.isGroupAccount) =>
-      account.userName -> getGroupMembers(account.userName).map(_.userName)
-    }.toMap
-
-    html.list(users, members, includeRemoved)
-  })
-  
-  get("/admin/users/_newuser")(adminOnly {
-    html.user(None)
-  })
-  
-  post("/admin/users/_newuser", newUserForm)(adminOnly { form =>
-    createAccount(form.userName, sha1(form.password), form.fullName, form.mailAddress, form.isAdmin, form.url)
-    updateImage(form.userName, form.fileId, false)
-    redirect("/admin/users")
-  })
-  
-  get("/admin/users/:userName/_edituser")(adminOnly {
-    val userName = params("userName")
-    html.user(getAccountByUserName(userName, true))
-  })
-  
-  post("/admin/users/:name/_edituser", editUserForm)(adminOnly { form =>
-    val userName = params("userName")
-    getAccountByUserName(userName, true).map { account =>
-
-      if(form.isRemoved){
-        // Remove repositories
-//        getRepositoryNamesOfUser(userName).foreach { repositoryName =>
-//          deleteRepository(userName, repositoryName)
-//          FileUtils.deleteDirectory(getRepositoryDir(userName, repositoryName))
-//          FileUtils.deleteDirectory(getWikiRepositoryDir(userName, repositoryName))
-//          FileUtils.deleteDirectory(getTemporaryDir(userName, repositoryName))
-//        }
-        // Remove from GROUP_MEMBER, COLLABORATOR and REPOSITORY
-        removeUserRelatedData(userName)
-      }
-
-      updateAccount(account.copy(
-        password     = form.password.map(sha1).getOrElse(account.password),
-        fullName     = form.fullName,
-        mailAddress  = form.mailAddress,
-        isAdmin      = form.isAdmin,
-        url          = form.url,
-        isRemoved    = form.isRemoved))
-
-      updateImage(userName, form.fileId, form.clearImage)
-      redirect("/admin/users")
-
-    } getOrElse NotFound
-  })
-
-  get("/admin/users/_newgroup")(adminOnly {
-    html.group(None, Nil)
-  })
-
-  post("/admin/users/_newgroup", newGroupForm)(adminOnly { form =>
-    createGroup(form.groupName, form.url)
-    updateGroupMembers(form.groupName, form.members.split(",").map {
-      _.split(":") match {
-        case Array(userName, isManager) => (userName, isManager.toBoolean)
-      }
-    }.toList)
-    updateImage(form.groupName, form.fileId, false)
-    redirect("/admin/users")
-  })
-
-  get("/admin/users/:groupName/_editgroup")(adminOnly {
-    defining(params("groupName")){ groupName =>
-      html.group(getAccountByUserName(groupName, true), getGroupMembers(groupName))
-    }
-  })
-
-  post("/admin/users/:groupName/_editgroup", editGroupForm)(adminOnly { form =>
-    defining(params("groupName"), form.members.split(",").map {
-      _.split(":") match {
-        case Array(userName, isManager) => (userName, isManager.toBoolean)
-      }
-    }.toList){ case (groupName, members) =>
-      getAccountByUserName(groupName, true).map { account =>
-        updateGroup(groupName, form.url, form.isRemoved)
-
-        if(form.isRemoved){
-          // Remove from GROUP_MEMBER
-          updateGroupMembers(form.groupName, Nil)
-          // Remove repositories
-          getRepositoryNamesOfUser(form.groupName).foreach { repositoryName =>
-            deleteRepository(groupName, repositoryName)
-            FileUtils.deleteDirectory(getRepositoryDir(groupName, repositoryName))
-            FileUtils.deleteDirectory(getWikiRepositoryDir(groupName, repositoryName))
-            FileUtils.deleteDirectory(getTemporaryDir(groupName, repositoryName))
-          }
-        } else {
-          // Update GROUP_MEMBER
-          updateGroupMembers(form.groupName, members)
-          // Update COLLABORATOR for group repositories
-          getRepositoryNamesOfUser(form.groupName).foreach { repositoryName =>
-            removeCollaborators(form.groupName, repositoryName)
-            members.foreach { case (userName, isManager) =>
-              addCollaborator(form.groupName, repositoryName, userName)
-            }
-          }
-        }
-
-        updateImage(form.groupName, form.fileId, form.clearImage)
-        redirect("/admin/users")
-
-      } getOrElse NotFound
-    }
-  })
-
-  private def members: Constraint = new Constraint(){
-    override def validate(name: String, value: String, messages: Messages): Option[String] = {
-      if(value.split(",").exists {
-        _.split(":") match { case Array(userName, isManager) => isManager.toBoolean }
-      }) None else Some("Must select one manager at least.")
-    }
-  }
-
-  protected def disableByNotYourself(paramName: String): Constraint = new Constraint() {
-    override def validate(name: String, value: String, messages: Messages): Option[String] = {
-      params.get(paramName).flatMap { userName =>
-        if(userName == context.loginAccount.get.userName && params.get("removed") == Some("true"))
-          Some("You can't disable your account yourself")
-        else
-          None
-      }
-    }
-  }
-}

src/main/scala/gitbucket/core/controller/WikiController.scala

@@ -7,12 +7,13 @@ import gitbucket.core.util.StringUtil._
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util.Directory._
-import jp.sf.amateras.scalatra.forms._
+import io.github.gitbucket.scalatra.forms._
 import org.eclipse.jgit.api.Git
 import org.scalatra.i18n.Messages
 
 class WikiController extends WikiControllerBase 
-  with WikiService with RepositoryService with AccountService with ActivityService with CollaboratorsAuthenticator with ReferrerAuthenticator
+  with WikiService with RepositoryService with AccountService with ActivityService
+  with CollaboratorsAuthenticator with ReferrerAuthenticator
 
 trait WikiControllerBase extends ControllerBase {
   self: WikiService with RepositoryService with ActivityService with CollaboratorsAuthenticator with ReferrerAuthenticator =>
@@ -38,7 +39,9 @@ trait WikiControllerBase extends ControllerBase {
   get("/:owner/:repository/wiki")(referrersOnly { repository =>
     getWikiPage(repository.owner, repository.name, "Home").map { page =>
       html.page("Home", page, getWikiPageList(repository.owner, repository.name),
-        repository, hasWritePermission(repository.owner, repository.name, context.loginAccount))
+        repository, hasWritePermission(repository.owner, repository.name, context.loginAccount),
+        getWikiPage(repository.owner, repository.name, "_Sidebar"),
+        getWikiPage(repository.owner, repository.name, "_Footer"))
     } getOrElse redirect(s"/${repository.owner}/${repository.name}/wiki/Home/_edit")
   })
   
@@ -47,7 +50,9 @@ trait WikiControllerBase extends ControllerBase {
 
     getWikiPage(repository.owner, repository.name, pageName).map { page =>
       html.page(pageName, page, getWikiPageList(repository.owner, repository.name),
-        repository, hasWritePermission(repository.owner, repository.name, context.loginAccount))
+        repository, hasWritePermission(repository.owner, repository.name, context.loginAccount),
+        getWikiPage(repository.owner, repository.name, "_Sidebar"),
+        getWikiPage(repository.owner, repository.name, "_Footer"))
     } getOrElse redirect(s"/${repository.owner}/${repository.name}/wiki/${StringUtil.urlEncode(pageName)}/_edit")
   })
   
@@ -124,7 +129,11 @@ trait WikiControllerBase extends ControllerBase {
         updateLastActivityDate(repository.owner, repository.name)
         recordEditWikiPageActivity(repository.owner, repository.name, loginAccount.userName, form.pageName, commitId)
       }
-      redirect(s"/${repository.owner}/${repository.name}/wiki/${StringUtil.urlEncode(form.pageName)}")
+      if(notReservedPageName(form.pageName)) {
+        redirect(s"/${repository.owner}/${repository.name}/wiki/${StringUtil.urlEncode(form.pageName)}")
+      } else {
+        redirect(s"/${repository.owner}/${repository.name}/wiki")
+      }
     }
   })
   
@@ -140,7 +149,11 @@ trait WikiControllerBase extends ControllerBase {
       updateLastActivityDate(repository.owner, repository.name)
       recordCreateWikiPageActivity(repository.owner, repository.name, loginAccount.userName, form.pageName)
 
-      redirect(s"/${repository.owner}/${repository.name}/wiki/${StringUtil.urlEncode(form.pageName)}")
+      if(notReservedPageName(form.pageName)) {
+        redirect(s"/${repository.owner}/${repository.name}/wiki/${StringUtil.urlEncode(form.pageName)}")
+      } else {
+        redirect(s"/${repository.owner}/${repository.name}/wiki")
+      }
     }
   })
   
@@ -186,13 +199,15 @@ trait WikiControllerBase extends ControllerBase {
     override def validate(name: String, value: String, messages: Messages): Option[String] =
       if(value.exists("\\/:*?\"<>|".contains(_))){
         Some(s"${name} contains invalid character.")
-      } else if(value.startsWith("_") || value.startsWith("-")){
+      } else if(notReservedPageName(value) && (value.startsWith("_") || value.startsWith("-"))){
         Some(s"${name} starts with invalid character.")
       } else {
         None
       }
   }
 
+  private def notReservedPageName(value: String) = ! (Array[String]("_Sidebar","_Footer") contains value)
+
   private def conflictForNew: Constraint = new Constraint(){
     override def validate(name: String, value: String, messages: Messages): Option[String] = {
       targetWikiPage.map { _ =>

src/main/scala/gitbucket/core/model/BasicTemplate.scala

@@ -26,12 +26,16 @@ protected[model] trait TemplateComponent { self: Profile =>
 
   trait LabelTemplate extends BasicTemplate { self: Table[_] =>
     val labelId = column[Int]("LABEL_ID")
+    val labelName = column[String]("LABEL_NAME")
 
     def byLabel(owner: String, repository: String, labelId: Int) =
       byRepository(owner, repository) && (this.labelId === labelId.bind)
 
     def byLabel(userName: Column[String], repositoryName: Column[String], labelId: Column[Int]) =
       byRepository(userName, repositoryName) && (this.labelId === labelId)
+
+    def byLabel(owner: String, repository: String, labelName: String) =
+      byRepository(owner, repository) && (this.labelName === labelName.bind)
   }
 
   trait MilestoneTemplate extends BasicTemplate { self: Table[_] =>
@@ -54,4 +58,9 @@ protected[model] trait TemplateComponent { self: Profile =>
       byRepository(userName, repositoryName) && (this.commitId === commitId)
   }
 
+  trait BranchTemplate extends BasicTemplate{ self: Table[_] =>
+    val branch = column[String]("BRANCH")
+    def byBranch(owner: String, repository: String, branchName: String) = byRepository(owner, repository) && (branch === branchName.bind)
+    def byBranch(owner: Column[String], repository: Column[String], branchName: Column[String]) = byRepository(owner, repository) && (this.branch === branchName)
+  }
 }

src/main/scala/gitbucket/core/model/CommitStatus.scala

@@ -19,7 +19,7 @@ trait CommitStatusComponent extends TemplateComponent { self: Profile =>
     val creator = column[String]("CREATOR")
     val registeredDate = column[java.util.Date]("REGISTERED_DATE")
     val updatedDate = column[java.util.Date]("UPDATED_DATE")
-    def * = (commitStatusId, userName, repositoryName, commitId, context, state, targetUrl, description, creator, registeredDate, updatedDate) <> (CommitStatus.tupled, CommitStatus.unapply)
+    def * = (commitStatusId, userName, repositoryName, commitId, context, state, targetUrl, description, creator, registeredDate, updatedDate) <> ((CommitStatus.apply _).tupled, CommitStatus.unapply)
     def byPrimaryKey(id: Int) = commitStatusId === id.bind
   }
 }
@@ -38,7 +38,20 @@ case class CommitStatus(
   registeredDate: java.util.Date,
   updatedDate: java.util.Date
 )
-
+object CommitStatus {
+  def pending(owner: String, repository: String, context: String) = CommitStatus(
+    commitStatusId = 0,
+    userName = owner,
+    repositoryName = repository,
+    commitId = "",
+    context = context,
+    state = CommitState.PENDING,
+    targetUrl = None,
+    description = Some("Waiting for status to be reported"),
+    creator = "",
+    registeredDate = new java.util.Date(),
+    updatedDate = new java.util.Date())
+}
 
 sealed abstract class CommitState(val name: String)
 

src/main/scala/gitbucket/core/model/Labels.scala

@@ -7,7 +7,7 @@ trait LabelComponent extends TemplateComponent { self: Profile =>
 
   class Labels(tag: Tag) extends Table[Label](tag, "LABEL") with LabelTemplate {
     override val labelId = column[Int]("LABEL_ID", O AutoInc)
-    val labelName = column[String]("LABEL_NAME")
+    override val labelName = column[String]("LABEL_NAME")
     val color = column[String]("COLOR")
     def * = (userName, repositoryName, labelId, labelName, color) <> (Label.tupled, Label.unapply)
 

src/main/scala/gitbucket/core/model/Profile.scala

@@ -50,5 +50,6 @@ trait CoreProfile extends ProfileProvider with Profile
   with WebHookComponent
   with WebHookEventComponent
   with PluginComponent
+  with ProtectedBranchComponent
 
 object Profile extends CoreProfile

src/main/scala/gitbucket/core/model/ProtectedBranch.scala

@@ -0,0 +1,37 @@
+package gitbucket.core.model
+
+import scala.slick.lifted.MappedTo
+import scala.slick.jdbc._
+
+trait ProtectedBranchComponent extends TemplateComponent { self: Profile =>
+  import profile.simple._
+  import self._
+
+  lazy val ProtectedBranches = TableQuery[ProtectedBranches]
+  class ProtectedBranches(tag: Tag) extends Table[ProtectedBranch](tag, "PROTECTED_BRANCH") with BranchTemplate {
+    val statusCheckAdmin = column[Boolean]("STATUS_CHECK_ADMIN")
+    def * = (userName, repositoryName, branch, statusCheckAdmin) <> (ProtectedBranch.tupled, ProtectedBranch.unapply)
+    def byPrimaryKey(userName: String, repositoryName: String, branch: String) = byBranch(userName, repositoryName, branch)
+    def byPrimaryKey(userName: Column[String], repositoryName: Column[String], branch: Column[String]) = byBranch(userName, repositoryName, branch)
+  }
+
+  lazy val ProtectedBranchContexts = TableQuery[ProtectedBranchContexts]
+  class ProtectedBranchContexts(tag: Tag) extends Table[ProtectedBranchContext](tag, "PROTECTED_BRANCH_REQUIRE_CONTEXT") with BranchTemplate {
+    val context = column[String]("CONTEXT")
+    def * = (userName, repositoryName, branch, context) <> (ProtectedBranchContext.tupled, ProtectedBranchContext.unapply)
+  }
+}
+
+
+case class ProtectedBranch(
+  userName: String,
+  repositoryName: String,
+  branch: String,
+  statusCheckAdmin: Boolean)
+
+
+case class ProtectedBranchContext(
+  userName: String,
+  repositoryName: String,
+  branch: String,
+  context: String)

src/main/scala/gitbucket/core/model/WebHook.scala

@@ -3,20 +3,43 @@ package gitbucket.core.model
 trait WebHookComponent extends TemplateComponent { self: Profile =>
   import profile.simple._
 
+  implicit val whContentTypeColumnType = MappedColumnType.base[WebHookContentType, String](whct => whct.code , code => WebHookContentType.valueOf(code))
+  
   lazy val WebHooks = TableQuery[WebHooks]
 
   class WebHooks(tag: Tag) extends Table[WebHook](tag, "WEB_HOOK") with BasicTemplate {
     val url = column[String]("URL")
-    def * = (userName, repositoryName, url) <> ((WebHook.apply _).tupled, WebHook.unapply)
+    val token = column[Option[String]]("TOKEN", O.Nullable)
+    val ctype = column[WebHookContentType]("CTYPE", O.NotNull)
+    def * = (userName, repositoryName, url, ctype, token) <> ((WebHook.apply _).tupled, WebHook.unapply)
 
     def byPrimaryKey(owner: String, repository: String, url: String) = byRepository(owner, repository) && (this.url === url.bind)
   }
 }
 
+case class WebHookContentType(val code: String, val ctype: String)
+
+object WebHookContentType {
+  object JSON extends WebHookContentType("json", "application/json")
+
+  object FORM extends WebHookContentType("form", "application/x-www-form-urlencoded")
+
+  val values: Vector[WebHookContentType] = Vector(JSON, FORM)
+
+  private val map: Map[String, WebHookContentType] = values.map(enum => enum.code -> enum).toMap
+
+  def apply(code: String): WebHookContentType = map(code)
+
+  def valueOf(code: String): WebHookContentType = map(code)
+  def valueOpt(code: String): Option[WebHookContentType] = map.get(code)
+}
+
 case class WebHook(
   userName: String,
   repositoryName: String,
-  url: String
+  url: String,
+  ctype: WebHookContentType,
+  token: Option[String]
 )
 
 object WebHook {

src/main/scala/gitbucket/core/plugin/Plugin.scala

@@ -1,16 +1,18 @@
 package gitbucket.core.plugin
 
 import javax.servlet.ServletContext
-import gitbucket.core.controller.ControllerBase
+import gitbucket.core.controller.{Context, ControllerBase}
+import gitbucket.core.model.Account
+import gitbucket.core.service.RepositoryService.RepositoryInfo
 import gitbucket.core.service.SystemSettingsService.SystemSettings
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Version
 
 /**
  * Trait for define plugin interface.
- * To provide plugin, put Plugin class which mixed in this trait into the package root.
+ * To provide a plugin, put a Plugin class which extends this class into the package root.
  */
-trait Plugin {
+abstract class Plugin {
 
   val pluginId: String
   val pluginName: String
@@ -67,6 +69,86 @@ trait Plugin {
    */
   def repositoryRoutings(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[GitRepositoryRouting] = Nil
 
+  /**
+   * Override to add receive hooks.
+   */
+  val receiveHooks: Seq[ReceiveHook] = Nil
+
+  /**
+   * Override to add receive hooks.
+   */
+  def receiveHooks(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[ReceiveHook] = Nil
+
+  /**
+   * Override to add global menus.
+   */
+  val globalMenus: Seq[(Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add global menus.
+   */
+  def globalMenus(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add repository menus.
+   */
+  val repositoryMenus: Seq[(RepositoryInfo, Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add repository menus.
+   */
+  def repositoryMenus(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(RepositoryInfo, Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add repository setting tabs.
+   */
+  val repositorySettingTabs: Seq[(RepositoryInfo, Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add repository setting tabs.
+   */
+  def repositorySettingTabs(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(RepositoryInfo, Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add profile tabs.
+   */
+  val profileTabs: Seq[(Account, Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add profile tabs.
+   */
+  def profileTabs(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(Account, Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add system setting menus.
+   */
+  val systemSettingMenus: Seq[(Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add system setting menus.
+   */
+  def systemSettingMenus(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add account setting menus.
+   */
+  val accountSettingMenus: Seq[(Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add account setting menus.
+   */
+  def accountSettingMenus(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add dashboard tabs.
+   */
+  val dashboardTabs: Seq[(Context) => Option[Link]] = Nil
+
+  /**
+   * Override to add dashboard tabs.
+   */
+  def dashboardTabs(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Seq[(Context) => Option[Link]] = Nil
+
   /**
    * This method is invoked in initialization of plugin system.
    * Register plugin functionality to PluginRegistry.
@@ -87,6 +169,30 @@ trait Plugin {
     (repositoryRoutings ++ repositoryRoutings(registry, context, settings)).foreach { routing =>
       registry.addRepositoryRouting(routing)
     }
+    (receiveHooks ++ receiveHooks(registry, context, settings)).foreach { receiveHook =>
+      registry.addReceiveHook(receiveHook)
+    }
+    (globalMenus ++ globalMenus(registry, context, settings)).foreach { globalMenu =>
+      registry.addGlobalMenu(globalMenu)
+    }
+    (repositoryMenus ++ repositoryMenus(registry, context, settings)).foreach { repositoryMenu =>
+      registry.addRepositoryMenu(repositoryMenu)
+    }
+    (repositorySettingTabs ++ repositorySettingTabs(registry, context, settings)).foreach { repositorySettingTab =>
+      registry.addRepositorySettingTab(repositorySettingTab)
+    }
+    (profileTabs ++ profileTabs(registry, context, settings)).foreach { profileTab =>
+      registry.addProfileTab(profileTab)
+    }
+    (systemSettingMenus ++ systemSettingMenus(registry, context, settings)).foreach { systemSettingMenu =>
+      registry.addSystemSettingMenu(systemSettingMenu)
+    }
+    (accountSettingMenus ++ accountSettingMenus(registry, context, settings)).foreach { accountSettingMenu =>
+      registry.addAccountSettingMenu(accountSettingMenu)
+    }
+    (dashboardTabs ++ dashboardTabs(registry, context, settings)).foreach { dashboardTab =>
+      registry.addDashboardTab(dashboardTab)
+    }
   }
 
   /**

src/main/scala/gitbucket/core/plugin/PluginRegistory.scala

@@ -3,9 +3,10 @@ package gitbucket.core.plugin
 import java.io.{File, FilenameFilter, InputStream}
 import java.net.URLClassLoader
 import javax.servlet.ServletContext
-import javax.servlet.http.{HttpServletRequest, HttpServletResponse}
 
 import gitbucket.core.controller.{Context, ControllerBase}
+import gitbucket.core.model.Account
+import gitbucket.core.service.ProtectedBranchService.ProtectedBranchReceiveHook
 import gitbucket.core.service.RepositoryService.RepositoryInfo
 import gitbucket.core.service.SystemSettingsService.SystemSettings
 import gitbucket.core.util.ControlUtil._
@@ -29,6 +30,16 @@ class PluginRegistry {
     "md" -> MarkdownRenderer, "markdown" -> MarkdownRenderer
   )
   private val repositoryRoutings = new ListBuffer[GitRepositoryRouting]
+  private val receiveHooks = new ListBuffer[ReceiveHook]
+  receiveHooks += new ProtectedBranchReceiveHook()
+
+  private val globalMenus = new ListBuffer[(Context) => Option[Link]]
+  private val repositoryMenus = new ListBuffer[(RepositoryInfo, Context) => Option[Link]]
+  private val repositorySettingTabs = new ListBuffer[(RepositoryInfo, Context) => Option[Link]]
+  private val profileTabs = new ListBuffer[(Account, Context) => Option[Link]]
+  private val systemSettingMenus = new ListBuffer[(Context) => Option[Link]]
+  private val accountSettingMenus = new ListBuffer[(Context) => Option[Link]]
+  private val dashboardTabs = new ListBuffer[(Context) => Option[Link]]
 
   def addPlugin(pluginInfo: PluginInfo): Unit = {
     plugins += pluginInfo
@@ -98,17 +109,53 @@ class PluginRegistry {
     }
   }
 
-  private case class GlobalAction(
-    method: String,
-    path: String,
-    function: (HttpServletRequest, HttpServletResponse, Context) => Any
-  )
+  def addReceiveHook(commitHook: ReceiveHook): Unit = {
+    receiveHooks += commitHook
+  }
 
-  private case class RepositoryAction(
-    method: String,
-    path: String,
-    function: (HttpServletRequest, HttpServletResponse, Context, RepositoryInfo) => Any
-  )
+  def getReceiveHooks: Seq[ReceiveHook] = receiveHooks.toSeq
+
+  def addGlobalMenu(globalMenu: (Context) => Option[Link]): Unit = {
+    globalMenus += globalMenu
+  }
+
+  def getGlobalMenus: Seq[(Context) => Option[Link]] = globalMenus.toSeq
+
+  def addRepositoryMenu(repositoryMenu: (RepositoryInfo, Context) => Option[Link]): Unit = {
+    repositoryMenus += repositoryMenu
+  }
+
+  def getRepositoryMenus: Seq[(RepositoryInfo, Context) => Option[Link]] = repositoryMenus.toSeq
+
+  def addRepositorySettingTab(repositorySettingTab: (RepositoryInfo, Context) => Option[Link]): Unit = {
+    repositorySettingTabs += repositorySettingTab
+  }
+
+  def getRepositorySettingTabs: Seq[(RepositoryInfo, Context) => Option[Link]] = repositorySettingTabs.toSeq
+
+  def addProfileTab(profileTab: (Account, Context) => Option[Link]): Unit = {
+    profileTabs += profileTab
+  }
+
+  def getProfileTabs: Seq[(Account, Context) => Option[Link]] = profileTabs.toSeq
+
+  def addSystemSettingMenu(systemSettingMenu: (Context) => Option[Link]): Unit = {
+    systemSettingMenus += systemSettingMenu
+  }
+
+  def getSystemSettingMenus: Seq[(Context) => Option[Link]] = systemSettingMenus.toSeq
+
+  def addAccountSettingMenu(accountSettingMenu: (Context) => Option[Link]): Unit = {
+    accountSettingMenus += accountSettingMenu
+  }
+
+  def getAccountSettingMenus: Seq[(Context) => Option[Link]] = accountSettingMenus.toSeq
+
+  def addDashboardTab(dashboardTab: (Context) => Option[Link]): Unit = {
+    dashboardTabs += dashboardTab
+  }
+
+  def getDashboardTabs: Seq[(Context) => Option[Link]] = dashboardTabs.toSeq
 
 }
 
@@ -169,7 +216,7 @@ object PluginRegistry {
           ))
 
         } catch {
-          case e: Exception => {
+          case e: Throwable => {
             logger.error(s"Error during plugin initialization", e)
           }
         }
@@ -192,6 +239,8 @@ object PluginRegistry {
 
 }
 
+case class Link(id: String, label: String, path: String, icon: Option[String] = None)
+
 case class PluginInfo(
   pluginId: String,
   pluginName: String,

src/main/scala/gitbucket/core/plugin/ReceiveHook.scala

@@ -0,0 +1,15 @@
+package gitbucket.core.plugin
+
+import gitbucket.core.model.Profile._
+import org.eclipse.jgit.transport.{ReceivePack, ReceiveCommand}
+import profile.simple._
+
+trait ReceiveHook {
+
+  def preReceive(owner: String, repository: String, receivePack: ReceivePack, command: ReceiveCommand, pusher: String)
+                (implicit session: Session): Option[String] = None
+
+  def postReceive(owner: String, repository: String, receivePack: ReceivePack, command: ReceiveCommand, pusher: String)
+                 (implicit session: Session): Unit = ()
+
+}

src/main/scala/gitbucket/core/service/CommitStatusService.scala

@@ -7,46 +7,51 @@ import gitbucket.core.model.{CommitState, CommitStatus, Account}
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util.StringUtil._
 import gitbucket.core.service.RepositoryService.RepositoryInfo
-
+import org.joda.time.LocalDateTime
+import gitbucket.core.model.Profile.dateColumnType
 
 trait CommitStatusService {
   /** insert or update */
-  def createCommitStatus(userName: String, repositoryName: String, sha:String, context:String, state:CommitState, targetUrl:Option[String], description:Option[String], now:java.util.Date, creator:Account)(implicit s: Session): Int =
-    CommitStatuses.filter(t => t.byCommit(userName, repositoryName, sha) && t.context===context.bind )
+  def createCommitStatus(userName: String, repositoryName: String, sha: String, context: String, state: CommitState,
+                         targetUrl: Option[String], description: Option[String], now: java.util.Date, creator: Account)(implicit s: Session): Int =
+    CommitStatuses
+      .filter(t => t.byCommit(userName, repositoryName, sha) && t.context === context.bind )
       .map(_.commitStatusId).firstOption match {
-    case Some(id:Int) => {
-      CommitStatuses.filter(_.byPrimaryKey(id)).map{
-        t => (t.state , t.targetUrl , t.updatedDate , t.creator, t.description)
-        }.update( (state, targetUrl, now, creator.userName, description) )
-        id
-      }
-    case None => (CommitStatuses returning CommitStatuses.map(_.commitStatusId)) += CommitStatus(
-        userName       = userName,
-        repositoryName = repositoryName,
-        commitId       = sha,
-        context        = context,
-        state          = state,
-        targetUrl      = targetUrl,
-        description    = description,
-        creator        = creator.userName,
-        registeredDate = now,
-        updatedDate    = now)
+        case Some(id: Int) => {
+          CommitStatuses.filter(_.byPrimaryKey(id)).map { t =>
+            (t.state , t.targetUrl , t.updatedDate , t.creator, t.description)
+          }.update((state, targetUrl, now, creator.userName, description))
+          id
+        }
+        case None => (CommitStatuses returning CommitStatuses.map(_.commitStatusId)) += CommitStatus(
+            userName       = userName,
+            repositoryName = repositoryName,
+            commitId       = sha,
+            context        = context,
+            state          = state,
+            targetUrl      = targetUrl,
+            description    = description,
+            creator        = creator.userName,
+            registeredDate = now,
+            updatedDate    = now)
       }
 
   def getCommitStatus(userName: String, repositoryName: String, id: Int)(implicit s: Session) :Option[CommitStatus] =
     CommitStatuses.filter(t => t.byPrimaryKey(id) && t.byRepository(userName, repositoryName)).firstOption
 
   def getCommitStatus(userName: String, repositoryName: String, sha: String, context: String)(implicit s: Session) :Option[CommitStatus] =
-    CommitStatuses.filter(t => t.byCommit(userName, repositoryName, sha) && t.context===context.bind ).firstOption
+    CommitStatuses.filter(t => t.byCommit(userName, repositoryName, sha) && t.context === context.bind).firstOption
 
   def getCommitStatues(userName: String, repositoryName: String, sha: String)(implicit s: Session) :List[CommitStatus] =
     byCommitStatues(userName, repositoryName, sha).list
 
+  def getRecentStatuesContexts(userName: String, repositoryName: String, time: java.util.Date)(implicit s: Session) :List[String] =
+    CommitStatuses.filter(t => t.byRepository(userName, repositoryName)).filter(t => t.updatedDate > time.bind).groupBy(_.context).map(_._1).list
+
   def getCommitStatuesWithCreator(userName: String, repositoryName: String, sha: String)(implicit s: Session) :List[(CommitStatus, Account)] =
-    byCommitStatues(userName, repositoryName, sha).innerJoin(Accounts)
-      .filter{ case (t,a) => t.creator === a.userName }.list
+    byCommitStatues(userName, repositoryName, sha).innerJoin(Accounts).filter { case (t, a) => t.creator === a.userName }.list
 
   protected def byCommitStatues(userName: String, repositoryName: String, sha: String)(implicit s: Session) = 
-    CommitStatuses.filter(t => t.byCommit(userName, repositoryName, sha) ).sortBy(_.updatedDate desc)
+    CommitStatuses.filter(t => t.byCommit(userName, repositoryName, sha)).sortBy(_.updatedDate desc)
 
 }

src/main/scala/gitbucket/core/service/HandleCommentService.scala

@@ -0,0 +1,91 @@
+package gitbucket.core.service
+
+import gitbucket.core.controller.Context
+import gitbucket.core.model.Issue
+import gitbucket.core.model.Profile._
+import gitbucket.core.util.ControlUtil._
+import gitbucket.core.util.Implicits._
+import gitbucket.core.util.Notifier
+import profile.simple._
+
+trait HandleCommentService {
+  self: RepositoryService with IssuesService with ActivityService
+    with WebHookService with WebHookIssueCommentService with WebHookPullRequestService =>
+
+  /**
+   * @see [[https://github.com/takezoe/gitbucket/wiki/CommentAction]]
+   */
+  def handleComment(issue: Issue, content: Option[String], repository: RepositoryService.RepositoryInfo, actionOpt: Option[String])
+                   (implicit context: Context, s: Session) = {
+
+    defining(repository.owner, repository.name){ case (owner, name) =>
+      val userName = context.loginAccount.get.userName
+
+      val (action, recordActivity) = actionOpt
+        .collect {
+          case "close" if(!issue.closed) => true  ->
+            (Some("close")  -> Some(if(issue.isPullRequest) recordClosePullRequestActivity _ else recordCloseIssueActivity _))
+          case "reopen" if(issue.closed) => false ->
+            (Some("reopen") -> Some(recordReopenIssueActivity _))
+        }
+        .map { case (closed, t) =>
+          updateClosed(owner, name, issue.issueId, closed)
+          t
+        }
+        .getOrElse(None -> None)
+
+      val commentId = (content, action) match {
+        case (None, None) => None
+        case (None, Some(action)) => Some(createComment(owner, name, userName, issue.issueId, action.capitalize, action))
+        case (Some(content), _) => Some(createComment(owner, name, userName, issue.issueId, content, action.map(_+ "_comment").getOrElse("comment")))
+      }
+
+      // record comment activity if comment is entered
+      content foreach {
+        (if(issue.isPullRequest) recordCommentPullRequestActivity _ else recordCommentIssueActivity _)
+        (owner, name, userName, issue.issueId, _)
+      }
+      recordActivity foreach ( _ (owner, name, userName, issue.issueId, issue.title) )
+
+      // extract references and create refer comment
+      content.map { content =>
+        createReferComment(owner, name, issue, content, context.loginAccount.get)
+      }
+
+      // call web hooks
+      action match {
+        case None => commentId.map{ commentIdSome => callIssueCommentWebHook(repository, issue, commentIdSome, context.loginAccount.get) }
+        case Some(act) => val webHookAction = act match {
+          case "open"   => "opened"
+          case "reopen" => "reopened"
+          case "close"  => "closed"
+          case _ => act
+        }
+          if(issue.isPullRequest){
+            callPullRequestWebHook(webHookAction, repository, issue.issueId, context.baseUrl, context.loginAccount.get)
+          } else {
+            callIssuesWebHook(webHookAction, repository, issue, context.baseUrl, context.loginAccount.get)
+          }
+      }
+
+      // notifications
+      Notifier() match {
+        case f =>
+          content foreach {
+            f.toNotify(repository, issue, _){
+              Notifier.msgComment(s"${context.baseUrl}/${owner}/${name}/${
+                if(issue.isPullRequest) "pull" else "issues"}/${issue.issueId}#comment-${commentId.get}")
+            }
+          }
+          action foreach {
+            f.toNotify(repository, issue, _){
+              Notifier.msgStatus(s"${context.baseUrl}/${owner}/${name}/issues/${issue.issueId}")
+            }
+          }
+      }
+
+      commentId.map( issue -> _ )
+    }
+  }
+
+}

src/main/scala/gitbucket/core/service/IssuesService.scala

@@ -1,6 +1,8 @@
 package gitbucket.core.service
 
 import gitbucket.core.model.Profile._
+import gitbucket.core.util.JGitUtil.CommitInfo
+import gitbucket.core.util.StringUtil
 import profile.simple._
 
 import gitbucket.core.util.StringUtil._
@@ -12,6 +14,7 @@ import Q.interpolation
 
 
 trait IssuesService {
+  self: AccountService =>
   import IssuesService._
 
   def getIssue(owner: String, repository: String, issueId: String)(implicit s: Session) =
@@ -394,12 +397,35 @@ trait IssuesService {
       }
     }
   }
+
+  def createReferComment(owner: String, repository: String, fromIssue: Issue, message: String, loginAccount: Account)(implicit s: Session) = {
+    StringUtil.extractIssueId(message).foreach { issueId =>
+      val content = fromIssue.issueId + ":" + fromIssue.title
+      if(getIssue(owner, repository, issueId).isDefined){
+        // Not add if refer comment already exist.
+        if(!getComments(owner, repository, issueId.toInt).exists { x => x.action == "refer" && x.content == content }) {
+          createComment(owner, repository, loginAccount.userName, issueId.toInt, content, "refer")
+        }
+      }
+    }
+  }
+
+  def createIssueComment(owner: String, repository: String, commit: CommitInfo)(implicit s: Session) = {
+    StringUtil.extractIssueId(commit.fullMessage).foreach { issueId =>
+      if(getIssue(owner, repository, issueId).isDefined){
+        getAccountByMailAddress(commit.committerEmailAddress).foreach { account =>
+          createComment(owner, repository, account.userName, issueId.toInt, commit.fullMessage + " " + commit.id, "commit")
+        }
+      }
+    }
+  }
+
 }
 
 object IssuesService {
   import javax.servlet.http.HttpServletRequest
 
-  val IssueLimit = 30
+  val IssueLimit = 25
 
   case class IssueSearchCondition(
       labels: Set[String] = Set.empty,

src/main/scala/gitbucket/core/service/LabelsService.scala

@@ -12,6 +12,9 @@ trait LabelsService {
   def getLabel(owner: String, repository: String, labelId: Int)(implicit s: Session): Option[Label] =
     Labels.filter(_.byPrimaryKey(owner, repository, labelId)).firstOption
 
+  def getLabel(owner: String, repository: String, labelName: String)(implicit s: Session): Option[Label] =
+    Labels.filter(_.byLabel(owner, repository, labelName)).firstOption
+
   def createLabel(owner: String, repository: String, labelName: String, color: String)(implicit s: Session): Int =
     Labels returning Labels.map(_.labelId) += Label(
       userName       = owner,

src/main/scala/gitbucket/core/service/MergeService.scala

@@ -10,10 +10,9 @@ import org.eclipse.jgit.merge.MergeStrategy
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.transport.RefSpec
 import org.eclipse.jgit.errors.NoMergeBaseException
-import org.eclipse.jgit.lib.{ObjectId, CommitBuilder, PersonIdent}
+import org.eclipse.jgit.lib.{ObjectId, CommitBuilder, PersonIdent, Repository}
 import org.eclipse.jgit.revwalk.RevWalk
 
-
 trait MergeService {
   import MergeService._
   /**
@@ -52,26 +51,30 @@ trait MergeService {
   /**
    * Checks whether conflict will be caused in merging. Returns true if conflict will be caused.
    */
-  def checkConflict(userName: String, repositoryName: String, branch: String,
-                            requestUserName: String, requestRepositoryName: String, requestBranch: String): Boolean = {
-    using(Git.open(getRepositoryDir(requestUserName, requestRepositoryName))) { git =>
-      val remoteRefName = s"refs/heads/${branch}"
-      val tmpRefName = s"refs/merge-check/${userName}/${branch}"
+  def tryMergeRemote(localUserName: String, localRepositoryName: String, localBranch: String,
+                      remoteUserName: String, remoteRepositoryName: String, remoteBranch: String): Option[(ObjectId, ObjectId, ObjectId)] = {
+    using(Git.open(getRepositoryDir(localUserName, localRepositoryName))) { git =>
+      val remoteRefName = s"refs/heads/${remoteBranch}"
+      val tmpRefName = s"refs/remote-temp/${remoteUserName}/${remoteRepositoryName}/${remoteBranch}"
       val refSpec = new RefSpec(s"${remoteRefName}:${tmpRefName}").setForceUpdate(true)
       try {
         // fetch objects from origin repository branch
         git.fetch
-           .setRemote(getRepositoryDir(userName, repositoryName).toURI.toString)
+           .setRemote(getRepositoryDir(remoteUserName, remoteRepositoryName).toURI.toString)
            .setRefSpecs(refSpec)
            .call
         // merge conflict check
         val merger = MergeStrategy.RECURSIVE.newMerger(git.getRepository, true)
-        val mergeBaseTip = git.getRepository.resolve(s"refs/heads/${requestBranch}")
+        val mergeBaseTip = git.getRepository.resolve(s"refs/heads/${localBranch}")
         val mergeTip = git.getRepository.resolve(tmpRefName)
         try {
-          !merger.merge(mergeBaseTip, mergeTip)
+          if(merger.merge(mergeBaseTip, mergeTip)){
+            Some((merger.getResultTreeId, mergeBaseTip, mergeTip))
+          } else {
+            None
+          }
         } catch {
-          case e: NoMergeBaseException =>  true
+          case e: NoMergeBaseException =>  None
         }
       } finally {
         val refUpdate = git.getRepository.updateRef(refSpec.getDestination)
@@ -80,8 +83,54 @@ trait MergeService {
       }
     }
   }
+  /**
+   * Checks whether conflict will be caused in merging. Returns true if conflict will be caused.
+   */
+  def checkConflict(userName: String, repositoryName: String, branch: String,
+                            requestUserName: String, requestRepositoryName: String, requestBranch: String): Boolean =
+    tryMergeRemote(userName, repositoryName, branch, requestUserName, requestRepositoryName, requestBranch).isEmpty
+
+  def pullRemote(localUserName: String, localRepositoryName: String, localBranch: String,
+                      remoteUserName: String, remoteRepositoryName: String, remoteBranch: String,
+                      loginAccount: Account, message: String): Option[ObjectId] = {
+    tryMergeRemote(localUserName, localRepositoryName, localBranch, remoteUserName, remoteRepositoryName, remoteBranch).map{ case (newTreeId, oldBaseId, oldHeadId) =>
+      using(Git.open(getRepositoryDir(localUserName, localRepositoryName))) { git =>
+        val committer = new PersonIdent(loginAccount.fullName, loginAccount.mailAddress)
+        val newCommit = Util.createMergeCommit(git.getRepository, newTreeId, committer, message, Seq(oldBaseId, oldHeadId))
+        Util.updateRefs(git.getRepository, s"refs/heads/${localBranch}", newCommit, false, committer, Some("merge"))
+      }
+      oldBaseId
+    }
+  }
+
 }
 object MergeService{
+  object Util{
+    // return treeId
+    def createMergeCommit(repository: Repository, treeId: ObjectId, committer: PersonIdent, message: String, parents: Seq[ObjectId]): ObjectId = {
+      val mergeCommit = new CommitBuilder()
+      mergeCommit.setTreeId(treeId)
+      mergeCommit.setParentIds(parents:_*)
+      mergeCommit.setAuthor(committer)
+      mergeCommit.setCommitter(committer)
+      mergeCommit.setMessage(message)
+      // insertObject and got mergeCommit Object Id
+      val inserter = repository.newObjectInserter
+      val mergeCommitId = inserter.insert(mergeCommit)
+      inserter.flush()
+      inserter.close()
+      mergeCommitId
+    }
+    def updateRefs(repository: Repository, ref: String, newObjectId: ObjectId, force: Boolean, committer: PersonIdent, refLogMessage: Option[String] = None):Unit = {
+      // update refs
+      val refUpdate = repository.updateRef(ref)
+      refUpdate.setNewObjectId(newObjectId)
+      refUpdate.setForceUpdate(force)
+      refUpdate.setRefLogIdent(committer)
+      refLogMessage.map(refUpdate.setRefLogMessage(_, true))
+      refUpdate.update()
+    }
+  }
   case class MergeCacheInfo(git:Git, branch:String, issueId:Int){
     val repository = git.getRepository
     val mergedBranchName = s"refs/pull/${issueId}/merge"
@@ -90,17 +139,17 @@ object MergeService{
     lazy val mergeTip = repository.resolve(s"refs/pull/${issueId}/head")
     def checkConflictCache(): Option[Boolean] = {
       Option(repository.resolve(mergedBranchName)).flatMap{ merged =>
-          if(parseCommit( merged ).getParents().toSet == Set( mergeBaseTip, mergeTip )){
+          if(parseCommit(merged).getParents().toSet == Set( mergeBaseTip, mergeTip )){
             // merged branch exists
             Some(false)
-          }else{
+          } else {
             None
           }
       }.orElse(Option(repository.resolve(conflictedBranchName)).flatMap{ conflicted =>
-        if(parseCommit( conflicted ).getParents().toSet == Set( mergeBaseTip, mergeTip )){
+        if(parseCommit(conflicted).getParents().toSet == Set( mergeBaseTip, mergeTip )){
           // conflict branch exists
           Some(true)
-        }else{
+        } else {
           None
         }
       })
@@ -120,17 +169,12 @@ object MergeService{
       def updateBranch(treeId:ObjectId, message:String, branchName:String){
         // creates merge commit
         val mergeCommitId = createMergeCommit(treeId, committer, message)
-        // update refs
-        val refUpdate = repository.updateRef(branchName)
-        refUpdate.setNewObjectId(mergeCommitId)
-        refUpdate.setForceUpdate(true)
-        refUpdate.setRefLogIdent(committer)
-        refUpdate.update()
+        Util.updateRefs(repository, branchName, mergeCommitId, true, committer)
       }
       if(!conflicted){
         updateBranch(merger.getResultTreeId, s"Merge ${mergeTip.name} into ${mergeBaseTip.name}", mergedBranchName)
         git.branchDelete().setForce(true).setBranchNames(conflictedBranchName).call()
-      }else{
+      } else {
         updateBranch(mergeTipCommit.getTree().getId(), s"can't merge ${mergeTip.name} into ${mergeBaseTip.name}", conflictedBranchName)
         git.branchDelete().setForce(true).setBranchNames(mergedBranchName).call()
       }
@@ -145,28 +189,12 @@ object MergeService{
       // creates merge commit
       val mergeCommitId = createMergeCommit(mergeResultCommit.getTree().getId(), committer, message)
       // update refs
-      val refUpdate = repository.updateRef(s"refs/heads/${branch}")
-      refUpdate.setNewObjectId(mergeCommitId)
-      refUpdate.setForceUpdate(false)
-      refUpdate.setRefLogIdent(committer)
-      refUpdate.setRefLogMessage("merged", true)
-      refUpdate.update()
+      Util.updateRefs(repository, s"refs/heads/${branch}", mergeCommitId, false, committer, Some("merged"))
     }
     // return treeId
-    private def createMergeCommit(treeId:ObjectId, committer:PersonIdent, message:String) = {
-      val mergeCommit = new CommitBuilder()
-      mergeCommit.setTreeId(treeId)
-      mergeCommit.setParentIds(Array[ObjectId](mergeBaseTip, mergeTip): _*)
-      mergeCommit.setAuthor(committer)
-      mergeCommit.setCommitter(committer)
-      mergeCommit.setMessage(message)
-      // insertObject and got mergeCommit Object Id
-      val inserter = repository.newObjectInserter
-      val mergeCommitId = inserter.insert(mergeCommit)
-      inserter.flush()
-      inserter.release()
-      mergeCommitId
-    }
+    private def createMergeCommit(treeId: ObjectId, committer: PersonIdent, message: String) =
+      Util.createMergeCommit(repository, treeId, committer, message, Seq[ObjectId](mergeBaseTip, mergeTip))
+
     private def parseCommit(id:ObjectId) = using(new RevWalk( repository ))(_.parseCommit(id))
   }
 }

src/main/scala/gitbucket/core/service/ProtectedBranchService.scala

@@ -0,0 +1,121 @@
+package gitbucket.core.service
+
+import gitbucket.core.model._
+import gitbucket.core.model.Profile._
+import gitbucket.core.plugin.ReceiveHook
+import profile.simple._
+
+import org.eclipse.jgit.transport.{ReceivePack, ReceiveCommand}
+
+
+trait ProtectedBranchService {
+  import ProtectedBranchService._
+  private def getProtectedBranchInfoOpt(owner: String, repository: String, branch: String)(implicit session: Session): Option[ProtectedBranchInfo] =
+    ProtectedBranches
+      .leftJoin(ProtectedBranchContexts)
+      .on{ case (pb, c) => pb.byBranch(c.userName, c.repositoryName, c.branch) }
+      .map{ case (pb, c) => pb -> c.context.? }
+      .filter(_._1.byPrimaryKey(owner, repository, branch))
+      .list
+      .groupBy(_._1)
+      .map(p => p._1 -> p._2.flatMap(_._2))
+      .map{ case (t1, contexts) =>
+        new ProtectedBranchInfo(t1.userName, t1.repositoryName, true, contexts, t1.statusCheckAdmin)
+      }.headOption
+
+  def getProtectedBranchInfo(owner: String, repository: String, branch: String)(implicit session: Session): ProtectedBranchInfo =
+    getProtectedBranchInfoOpt(owner, repository, branch).getOrElse(ProtectedBranchInfo.disabled(owner, repository))
+
+  def getProtectedBranchList(owner: String, repository: String)(implicit session: Session): List[String] =
+    ProtectedBranches.filter(_.byRepository(owner, repository)).map(_.branch).list
+
+  def enableBranchProtection(owner: String, repository: String, branch:String, includeAdministrators: Boolean, contexts: Seq[String])
+                            (implicit session: Session): Unit = {
+    disableBranchProtection(owner, repository, branch)
+    ProtectedBranches.insert(new ProtectedBranch(owner, repository, branch, includeAdministrators && contexts.nonEmpty))
+    contexts.map{ context =>
+      ProtectedBranchContexts.insert(new ProtectedBranchContext(owner, repository, branch, context))
+    }
+  }
+
+  def disableBranchProtection(owner: String, repository: String, branch:String)(implicit session: Session): Unit =
+    ProtectedBranches.filter(_.byPrimaryKey(owner, repository, branch)).delete
+
+}
+
+object ProtectedBranchService {
+
+  class ProtectedBranchReceiveHook extends ReceiveHook with ProtectedBranchService {
+    override def preReceive(owner: String, repository: String, receivePack: ReceivePack, command: ReceiveCommand, pusher: String)
+                           (implicit session: Session): Option[String] = {
+      val branch = command.getRefName.stripPrefix("refs/heads/")
+      if(branch != command.getRefName){
+        getProtectedBranchInfo(owner, repository, branch).getStopReason(receivePack.isAllowNonFastForwards, command, pusher)
+      } else {
+        None
+      }
+    }
+  }
+
+
+  case class ProtectedBranchInfo(
+    owner: String,
+    repository: String,
+    enabled: Boolean,
+    /**
+     * Require status checks to pass before merging
+     * Choose which status checks must pass before branches can be merged into test.
+     * When enabled, commits must first be pushed to another branch,
+     * then merged or pushed directly to test after status checks have passed.
+     */
+    contexts: Seq[String],
+    /**
+     * Include administrators
+     * Enforce required status checks for repository administrators.
+     */
+    includeAdministrators: Boolean) extends AccountService with CommitStatusService {
+
+    def isAdministrator(pusher: String)(implicit session: Session): Boolean =
+      pusher == owner || getGroupMembers(owner).filter(gm => gm.userName == pusher && gm.isManager).nonEmpty
+
+    /**
+     * Can't be force pushed
+     * Can't be deleted
+     * Can't have changes merged into them until required status checks pass
+     */
+    def getStopReason(isAllowNonFastForwards: Boolean, command: ReceiveCommand, pusher: String)(implicit session: Session): Option[String] = {
+      if(enabled){
+        command.getType() match {
+          case ReceiveCommand.Type.UPDATE|ReceiveCommand.Type.UPDATE_NONFASTFORWARD if isAllowNonFastForwards =>
+            Some("Cannot force-push to a protected branch")
+          case ReceiveCommand.Type.UPDATE|ReceiveCommand.Type.UPDATE_NONFASTFORWARD if needStatusCheck(pusher) =>
+            unSuccessedContexts(command.getNewId.name) match {
+              case s if s.size == 1 => Some(s"""Required status check "${s.toSeq(0)}" is expected""")
+              case s if s.size >= 1 => Some(s"${s.size} of ${contexts.size} required status checks are expected")
+              case _ => None
+            }
+          case ReceiveCommand.Type.DELETE =>
+            Some("Cannot delete a protected branch")
+          case _ => None
+        }
+      }else{
+        None
+      }
+    }
+    def unSuccessedContexts(sha1: String)(implicit session: Session): Set[String] = if(contexts.isEmpty){
+      Set.empty
+    } else {
+      contexts.toSet -- getCommitStatues(owner, repository, sha1).filter(_.state == CommitState.SUCCESS).map(_.context).toSet
+    }
+    def needStatusCheck(pusher: String)(implicit session: Session): Boolean = pusher match {
+      case _ if !enabled              => false
+      case _ if contexts.isEmpty      => false
+      case _ if includeAdministrators => true
+      case p if isAdministrator(p)    => false
+      case _                          => true
+    }
+  }
+  object ProtectedBranchInfo{
+    def disabled(owner: String, repository: String): ProtectedBranchInfo = ProtectedBranchInfo(owner, repository, false, Nil, false)
+  }
+}

src/main/scala/gitbucket/core/service/PullRequestService.scala

@@ -1,6 +1,6 @@
 package gitbucket.core.service
 
-import gitbucket.core.model.{Account, Issue, PullRequest, WebHook}
+import gitbucket.core.model.{Account, Issue, PullRequest, WebHook, CommitStatus, CommitState}
 import gitbucket.core.model.Profile._
 import gitbucket.core.util.JGitUtil
 import profile.simple._
@@ -145,4 +145,29 @@ object PullRequestService {
 
   case class PullRequestCount(userName: String, count: Int)
 
+  case class MergeStatus(
+    hasConflict: Boolean,
+    commitStatues:List[CommitStatus],
+    branchProtection: ProtectedBranchService.ProtectedBranchInfo,
+    branchIsOutOfDate: Boolean,
+    hasUpdatePermission: Boolean,
+    needStatusCheck: Boolean,
+    hasMergePermission: Boolean,
+    commitIdTo: String){
+
+    val statuses: List[CommitStatus] =
+      commitStatues ++ (branchProtection.contexts.toSet -- commitStatues.map(_.context).toSet).map(CommitStatus.pending(branchProtection.owner, branchProtection.repository, _))
+    val hasRequiredStatusProblem = needStatusCheck && branchProtection.contexts.exists(context => statuses.find(_.context == context).map(_.state) != Some(CommitState.SUCCESS))
+    val hasProblem = hasRequiredStatusProblem || hasConflict || (!statuses.isEmpty && CommitState.combine(statuses.map(_.state).toSet) != CommitState.SUCCESS)
+    val canUpdate = branchIsOutOfDate && !hasConflict
+    val canMerge = hasMergePermission && !hasConflict && !hasRequiredStatusProblem
+    lazy val commitStateSummary:(CommitState, String) = {
+      val stateMap = statuses.groupBy(_.state)
+      val state = CommitState.combine(stateMap.keySet)
+      val summary = stateMap.map{ case (keyState, states) => states.size+" "+keyState.name }.mkString(", ")
+      state -> summary
+    }
+    lazy val statusesAndRequired:List[(CommitStatus, Boolean)] = statuses.map{ s => s -> branchProtection.contexts.exists(_==s.context) }
+    lazy val isAllSuccess = commitStateSummary._1==CommitState.SUCCESS
+  }
 }

src/main/scala/gitbucket/core/service/RepositoryCreationService.scala

@@ -0,0 +1,79 @@
+package gitbucket.core.service
+
+import gitbucket.core.model.Profile._
+import gitbucket.core.util.ControlUtil._
+import gitbucket.core.util.Directory._
+import gitbucket.core.util.JGitUtil
+import gitbucket.core.model.Account
+import org.eclipse.jgit.api.Git
+import org.eclipse.jgit.dircache.DirCache
+import org.eclipse.jgit.lib.{FileMode, Constants}
+import profile.simple._
+
+trait RepositoryCreationService {
+  self: AccountService with RepositoryService with LabelsService with WikiService with ActivityService =>
+
+  def createRepository(loginAccount: Account, owner: String, name: String, description: Option[String], isPrivate: Boolean, createReadme: Boolean)
+                      (implicit s: Session) {
+    val ownerAccount  = getAccountByUserName(owner).get
+    val loginUserName = loginAccount.userName
+
+    // Insert to the database at first
+    insertRepository(name, owner, description, isPrivate)
+
+    // Add collaborators for group repository
+    if(ownerAccount.isGroupAccount){
+      getGroupMembers(owner).foreach { member =>
+        addCollaborator(owner, name, member.userName)
+      }
+    }
+
+    // Insert default labels
+    insertDefaultLabels(owner, name)
+
+    // Create the actual repository
+    val gitdir = getRepositoryDir(owner, name)
+    JGitUtil.initRepository(gitdir)
+
+    if(createReadme){
+      using(Git.open(gitdir)){ git =>
+        val builder  = DirCache.newInCore.builder()
+        val inserter = git.getRepository.newObjectInserter()
+        val headId   = git.getRepository.resolve(Constants.HEAD + "^{commit}")
+        val content  = if(description.nonEmpty){
+          name + "\n" +
+            "===============\n" +
+            "\n" +
+            description.get
+        } else {
+          name + "\n" +
+            "===============\n"
+        }
+
+        builder.add(JGitUtil.createDirCacheEntry("README.md", FileMode.REGULAR_FILE,
+          inserter.insert(Constants.OBJ_BLOB, content.getBytes("UTF-8"))))
+        builder.finish()
+
+        JGitUtil.createNewCommit(git, inserter, headId, builder.getDirCache.writeTree(inserter),
+          Constants.HEAD, loginAccount.fullName, loginAccount.mailAddress, "Initial commit")
+      }
+    }
+
+    // Create Wiki repository
+    createWikiRepository(loginAccount, owner, name)
+
+    // Record activity
+    recordCreateRepositoryActivity(owner, name, loginUserName)
+  }
+
+  def insertDefaultLabels(userName: String, repositoryName: String)(implicit s: Session): 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")
+  }
+
+
+}

src/main/scala/gitbucket/core/service/RepositorySearchService.scala

@@ -53,7 +53,30 @@ trait RepositorySearchService { self: IssuesService =>
       }
     }
 
-  private def searchRepositoryFiles(git: Git, query: String): List[(String, String)] = {
+  def countWikiPages(owner: String, repository: String, query: String): Int =
+    using(Git.open(Directory.getWikiRepositoryDir(owner, repository))){ git =>
+      if(JGitUtil.isEmpty(git)) 0 else searchRepositoryFiles(git, query).length
+    }
+
+  def searchWikiPages(owner: String, repository: String, query: String): List[FileSearchResult] =
+    using(Git.open(Directory.getWikiRepositoryDir(owner, repository))){ git =>
+      if(JGitUtil.isEmpty(git)){
+        Nil
+      } else {
+        val files = searchRepositoryFiles(git, query)
+        val commits = JGitUtil.getLatestCommitFromPaths(git, files.map(_._1), "HEAD")
+        files.map { case (path, text) =>
+          val (highlightText, lineNumber) = getHighlightText(text, query)
+          FileSearchResult(
+            path.replaceFirst("\\.md$", ""),
+            commits(path).getCommitterIdent.getWhen,
+            highlightText,
+            lineNumber)
+        }
+      }
+    }
+
+  def searchRepositoryFiles(git: Git, query: String): List[(String, String)] = {
     val revWalk   = new RevWalk(git.getRepository)
     val objectId  = git.getRepository.resolve("HEAD")
     val revCommit = revWalk.parseCommit(objectId)
@@ -79,8 +102,8 @@ trait RepositorySearchService { self: IssuesService =>
         }
       }
     }
-    treeWalk.release
-    revWalk.release
+    treeWalk.close()
+    revWalk.close()
 
     list.toList
   }

src/main/scala/gitbucket/core/service/RepositoryService.scala

@@ -1,5 +1,6 @@
 package gitbucket.core.service
 
+import gitbucket.core.controller.Context
 import gitbucket.core.model.{Collaborator, Repository, Account}
 import gitbucket.core.model.Profile._
 import gitbucket.core.util.JGitUtil
@@ -18,7 +19,7 @@ trait RepositoryService { self: AccountService =>
    * @param originRepositoryName specify for the forked repository. (default is None)
    * @param originUserName specify for the forked repository. (default is None)
    */
-  def createRepository(repositoryName: String, userName: String, description: Option[String], isPrivate: Boolean,
+  def insertRepository(repositoryName: String, userName: String, description: Option[String], isPrivate: Boolean,
                        originRepositoryName: Option[String] = None, originUserName: Option[String] = None,
                        parentRepositoryName: Option[String] = None, parentUserName: Option[String] = None)
                       (implicit s: Session): Unit = {
@@ -46,18 +47,20 @@ trait RepositoryService { self: AccountService =>
       (Repositories filter { t => t.byRepository(oldUserName, oldRepositoryName) } firstOption).map { repository =>
         Repositories insert repository.copy(userName = newUserName, repositoryName = newRepositoryName)
 
-        val webHooks       = WebHooks      .filter(_.byRepository(oldUserName, oldRepositoryName)).list
-        val webHookEvents  = WebHookEvents .filter(_.byRepository(oldUserName, oldRepositoryName)).list
-        val milestones     = Milestones    .filter(_.byRepository(oldUserName, oldRepositoryName)).list
-        val issueId        = IssueId       .filter(_.byRepository(oldUserName, oldRepositoryName)).list
-        val issues         = Issues        .filter(_.byRepository(oldUserName, oldRepositoryName)).list
-        val pullRequests   = PullRequests  .filter(_.byRepository(oldUserName, oldRepositoryName)).list
-        val labels         = Labels        .filter(_.byRepository(oldUserName, oldRepositoryName)).list
-        val issueComments  = IssueComments .filter(_.byRepository(oldUserName, oldRepositoryName)).list
-        val issueLabels    = IssueLabels   .filter(_.byRepository(oldUserName, oldRepositoryName)).list
-        val commitComments = CommitComments.filter(_.byRepository(oldUserName, oldRepositoryName)).list
-        val commitStatuses = CommitStatuses.filter(_.byRepository(oldUserName, oldRepositoryName)).list
-        val collaborators  = Collaborators .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val webHooks                = WebHooks               .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val webHookEvents           = WebHookEvents          .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val milestones              = Milestones             .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val issueId                 = IssueId                .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val issues                  = Issues                 .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val pullRequests            = PullRequests           .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val labels                  = Labels                 .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val issueComments           = IssueComments          .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val issueLabels             = IssueLabels            .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val commitComments          = CommitComments         .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val commitStatuses          = CommitStatuses         .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val collaborators           = Collaborators          .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val protectedBranches       = ProtectedBranches      .filter(_.byRepository(oldUserName, oldRepositoryName)).list
+        val protectedBranchContexts = ProtectedBranchContexts.filter(_.byRepository(oldUserName, oldRepositoryName)).list
 
         Repositories.filter { t =>
           (t.originUserName === oldUserName.bind) && (t.originRepositoryName === oldRepositoryName.bind)
@@ -90,11 +93,13 @@ trait RepositoryService { self: AccountService =>
           }
         )} :_*)
 
-        PullRequests  .insertAll(pullRequests  .map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
-        IssueComments .insertAll(issueComments .map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
-        Labels        .insertAll(labels        .map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
-        CommitComments.insertAll(commitComments.map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
-        CommitStatuses.insertAll(commitStatuses.map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
+        PullRequests           .insertAll(pullRequests  .map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
+        IssueComments          .insertAll(issueComments .map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
+        Labels                 .insertAll(labels        .map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
+        CommitComments         .insertAll(commitComments.map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
+        CommitStatuses         .insertAll(commitStatuses.map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
+        ProtectedBranches      .insertAll(protectedBranches.map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
+        ProtectedBranchContexts.insertAll(protectedBranchContexts.map(_.copy(userName = newUserName, repositoryName = newRepositoryName)) :_*)
 
         // Update source repository of pull requests
         PullRequests.filter { t =>
@@ -190,10 +195,9 @@ trait RepositoryService { self: AccountService =>
    * 
    * @param userName the user name of the repository owner
    * @param repositoryName the repository name
-   * @param baseUrl the base url of this application
    * @return the repository information
    */
-  def getRepository(userName: String, repositoryName: String, baseUrl: String)(implicit s: Session): Option[RepositoryInfo] = {
+  def getRepository(userName: String, repositoryName: String)(implicit s: Session): Option[RepositoryInfo] = {
     (Repositories filter { t => t.byRepository(userName, repositoryName) } firstOption) map { repository =>
       // for getting issue count and pull request count
       val issues = Issues.filter { t =>
@@ -201,7 +205,7 @@ trait RepositoryService { self: AccountService =>
       }.map(_.pullRequest).list
 
       new RepositoryInfo(
-        JGitUtil.getRepositoryInfo(repository.userName, repository.repositoryName, baseUrl),
+        JGitUtil.getRepositoryInfo(repository.userName, repository.repositoryName),
         repository,
         issues.count(_ == false),
         issues.count(_ == true),
@@ -230,7 +234,7 @@ trait RepositoryService { self: AccountService =>
     }.list
   }
 
-  def getUserRepositories(userName: String, baseUrl: String, withoutPhysicalInfo: Boolean = false)
+  def getUserRepositories(userName: String, withoutPhysicalInfo: Boolean = false)
                          (implicit s: Session): List[RepositoryInfo] = {
     Repositories.filter { t1 =>
       (t1.userName === userName.bind) ||
@@ -238,9 +242,9 @@ trait RepositoryService { self: AccountService =>
     }.sortBy(_.lastActivityDate desc).list.map{ repository =>
       new RepositoryInfo(
         if(withoutPhysicalInfo){
-          new JGitUtil.RepositoryInfo(repository.userName, repository.repositoryName, baseUrl)
+          new JGitUtil.RepositoryInfo(repository.userName, repository.repositoryName)
         } else {
-          JGitUtil.getRepositoryInfo(repository.userName, repository.repositoryName, baseUrl)
+          JGitUtil.getRepositoryInfo(repository.userName, repository.repositoryName)
         },
         repository,
         getForkedCount(
@@ -256,13 +260,12 @@ trait RepositoryService { self: AccountService =>
    * If repositoryUserName is given then filters results by repository owner.
    *
    * @param loginAccount the logged in account
-   * @param baseUrl the base url of this application
    * @param repositoryUserName the repository owner (if None then returns all repositories which are visible for logged in user)
    * @param withoutPhysicalInfo if true then the result does not include physical repository information such as commit count,
    *                            branches and tags
    * @return the repository information which is sorted in descending order of lastActivityDate.
    */
-  def getVisibleRepositories(loginAccount: Option[Account], baseUrl: String, repositoryUserName: Option[String] = None,
+  def getVisibleRepositories(loginAccount: Option[Account], repositoryUserName: Option[String] = None,
                              withoutPhysicalInfo: Boolean = false)
                             (implicit s: Session): List[RepositoryInfo] = {
     (loginAccount match {
@@ -280,9 +283,9 @@ trait RepositoryService { self: AccountService =>
     }.sortBy(_.lastActivityDate desc).list.map{ repository =>
       new RepositoryInfo(
         if(withoutPhysicalInfo){
-          new JGitUtil.RepositoryInfo(repository.userName, repository.repositoryName, baseUrl)
+          new JGitUtil.RepositoryInfo(repository.userName, repository.repositoryName)
         } else {
-          JGitUtil.getRepositoryInfo(repository.userName, repository.repositoryName, baseUrl)
+          JGitUtil.getRepositoryInfo(repository.userName, repository.repositoryName)
         },
         repository,
         getForkedCount(
@@ -309,11 +312,17 @@ trait RepositoryService { self: AccountService =>
   /**
    * Save repository options.
    */
-  def saveRepositoryOptions(userName: String, repositoryName: String, 
-      description: Option[String], defaultBranch: String, isPrivate: Boolean)(implicit s: Session): Unit =
+  def saveRepositoryOptions(userName: String, repositoryName: String,
+      description: Option[String], isPrivate: Boolean)(implicit s: Session): Unit =
     Repositories.filter(_.byRepository(userName, repositoryName))
-      .map { r => (r.description.?, r.defaultBranch, r.isPrivate, r.updatedDate) }
-      .update (description, defaultBranch, isPrivate, currentDate)
+      .map { r => (r.description.?, r.isPrivate, r.updatedDate) }
+      .update (description, isPrivate, currentDate)
+
+  def saveRepositoryDefaultBranch(userName: String, repositoryName: String,
+      defaultBranch: String)(implicit s: Session): Unit =
+    Repositories.filter(_.byRepository(userName, repositoryName))
+      .map { r => r.defaultBranch }
+      .update (defaultBranch)
 
   /**
    * Add collaborator to the repository.
@@ -379,32 +388,39 @@ trait RepositoryService { self: AccountService =>
 
 object RepositoryService {
 
-  case class RepositoryInfo(owner: String, name: String, httpUrl: String, repository: Repository,
+  case class RepositoryInfo(owner: String, name: String, repository: Repository,
     issueCount: Int, pullCount: Int, commitCount: Int, forkedCount: Int,
-    branchList: Seq[String], tags: Seq[JGitUtil.TagInfo], managers: Seq[String]){
-
-    lazy val host = """^https?://(.+?)(:\d+)?/""".r.findFirstMatchIn(httpUrl).get.group(1)
-
-    def sshUrl(port: Int, userName: String) = s"ssh://${userName}@${host}:${port}/${owner}/${name}.git"
-
-    def sshOpenRepoUrl(platform: String, port: Int, userName: String) = openRepoUrl(platform, sshUrl(port, userName))
-
-    def httpOpenRepoUrl(platform: String) = openRepoUrl(platform, httpUrl)
-
-    def openRepoUrl(platform: String, openUrl: String) = s"github-${platform}://openRepo/${openUrl}"
+    branchList: Seq[String], tags: Seq[JGitUtil.TagInfo], managers: Seq[String]) {
 
     /**
      * Creates instance with issue count and pull request count.
      */
     def this(repo: JGitUtil.RepositoryInfo, model: Repository, issueCount: Int, pullCount: Int, forkedCount: Int, managers: Seq[String]) =
-      this(repo.owner, repo.name, repo.url, model, issueCount, pullCount, repo.commitCount, forkedCount, repo.branchList, repo.tags, managers)
+      this(
+        repo.owner, repo.name, model,
+        issueCount, pullCount, repo.commitCount, forkedCount,
+        repo.branchList, repo.tags, managers)
 
     /**
      * Creates instance without issue count and pull request count.
      */
-    def this(repo: JGitUtil.RepositoryInfo, model: Repository, forkedCount: Int, managers: Seq[String]) =
-      this(repo.owner, repo.name, repo.url, model, 0, 0, repo.commitCount, forkedCount, repo.branchList, repo.tags, managers)
+    def this(repo: JGitUtil.RepositoryInfo, model: Repository, 	forkedCount: Int, managers: Seq[String]) =
+      this(
+        repo.owner, repo.name, model,
+        0, 0, repo.commitCount, forkedCount,
+        repo.branchList, repo.tags, managers)
+
+    def httpUrl(implicit context: Context): String = RepositoryService.httpUrl(owner, name)
+    def sshUrl(implicit context: Context): Option[String] = RepositoryService.sshUrl(owner, name)
   }
 
-  case class RepositoryTreeNode(owner: String, name: String, children: List[RepositoryTreeNode])
+  def httpUrl(owner: String, name: String)(implicit context: Context): String = s"${context.baseUrl}/git/${owner}/${name}.git"
+  def sshUrl(owner: String, name: String)(implicit context: Context): Option[String] =
+    if(context.settings.ssh){
+      context.loginAccount.flatMap { loginAccount =>
+        context.settings.sshAddress.map { x => s"ssh://${loginAccount.userName}@${x.host}:${x.port}/${owner}/${name}.git" }
+      }
+    } else None
+  def openRepoUrl(openUrl: String)(implicit context: Context): String = s"github-${context.platform}://openRepo/${openUrl}"
+
 }

src/main/scala/gitbucket/core/service/SystemSettingsService.scala

@@ -1,6 +1,7 @@
 package gitbucket.core.service
 
 import gitbucket.core.util.{Directory, ControlUtil}
+import gitbucket.core.util.Implicits._
 import Directory._
 import ControlUtil._
 import SystemSettingsService._
@@ -21,6 +22,7 @@ trait SystemSettingsService {
       props.setProperty(Notification, settings.notification.toString)
       settings.activityLogLimit.foreach(x => props.setProperty(ActivityLogLimit, x.toString))
       props.setProperty(Ssh, settings.ssh.toString)
+      settings.sshHost.foreach(x => props.setProperty(SshHost, x.trim))
       settings.sshPort.foreach(x => props.setProperty(SshPort, x.toString))
       props.setProperty(UseSMTP, settings.useSMTP.toString)
       if(settings.useSMTP) {
@@ -75,6 +77,7 @@ trait SystemSettingsService {
         getValue(props, Notification, false),
         getOptionValue[Int](props, ActivityLogLimit, None),
         getValue(props, Ssh, false),
+        getOptionValue[String](props, SshHost, None).map(_.trim),
         getOptionValue(props, SshPort, Some(DefaultSshPort)),
         getValue(props, UseSMTP, getValue(props, Notification, false)),   // handle migration scenario from only notification to useSMTP
         if(getValue(props, UseSMTP, getValue(props, Notification, false))){
@@ -126,16 +129,19 @@ object SystemSettingsService {
     notification: Boolean,
     activityLogLimit: Option[Int],
     ssh: Boolean,
+    sshHost: Option[String],
     sshPort: Option[Int],
     useSMTP: Boolean,
     smtp: Option[Smtp],
     ldapAuthentication: Boolean,
     ldap: Option[Ldap]){
-    def baseUrl(request: HttpServletRequest): String = baseUrl.getOrElse {
-      defining(request.getRequestURL.toString){ url =>
-        url.substring(0, url.length - (request.getRequestURI.length - request.getContextPath.length))
+    def baseUrl(request: HttpServletRequest): String = baseUrl.fold(request.baseUrl)(_.stripSuffix("/"))
+
+    def sshAddress:Option[SshAddress] =
+      for {
+        host <- sshHost if ssh
       }
-    }.stripSuffix("/")
+      yield SshAddress(host, sshPort.getOrElse(DefaultSshPort))
   }
 
   case class Ldap(
@@ -161,6 +167,10 @@ object SystemSettingsService {
     fromAddress: Option[String],
     fromName: Option[String])
 
+  case class SshAddress(
+    host:String,
+    port:Int)
+
   val DefaultSshPort = 29418
   val DefaultSmtpPort = 25
   val DefaultLdapPort = 389
@@ -174,6 +184,7 @@ object SystemSettingsService {
   private val Notification = "notification"
   private val ActivityLogLimit = "activity_log_limit"
   private val Ssh = "ssh"
+  private val SshHost = "ssh.host"
   private val SshPort = "ssh.port"
   private val UseSMTP = "useSMTP"
   private val SmtpHost = "smtp.host"
@@ -216,7 +227,4 @@ object SystemSettingsService {
       else value
     }
 
-//  // TODO temporary flag
-//  val enablePluginSystem = Option(System.getProperty("enable.plugin")).getOrElse("false").toBoolean
-
 }

src/main/scala/gitbucket/core/service/WebHookService.scala

@@ -1,13 +1,16 @@
 package gitbucket.core.service
 
+import java.io.ByteArrayInputStream
+import fr.brouillard.oss.security.xhub.XHub
+import fr.brouillard.oss.security.xhub.XHub.{XHubDigest, XHubConverter}
 import gitbucket.core.api._
 import gitbucket.core.model.{WebHook, Account, Issue, PullRequest, IssueComment, WebHookEvent, CommitComment}
 import gitbucket.core.model.Profile._
+import org.apache.http.client.utils.URLEncodedUtils
 import profile.simple._
 import gitbucket.core.util.JGitUtil.CommitInfo
 import gitbucket.core.util.RepositoryName
 import gitbucket.core.service.RepositoryService.RepositoryInfo
-
 import org.apache.http.NameValuePair
 import org.apache.http.client.entity.UrlEncodedFormEntity
 import org.apache.http.message.BasicNameValuePair
@@ -17,6 +20,8 @@ import org.slf4j.LoggerFactory
 import scala.concurrent._
 import org.apache.http.HttpRequest
 import org.apache.http.HttpResponse
+import gitbucket.core.model.WebHookContentType
+import org.apache.http.client.entity.EntityBuilder
 
 
 trait WebHookService {
@@ -33,8 +38,11 @@ trait WebHookService {
 
   /** get All WebHook informations of repository event */
   def getWebHooksByEvent(owner: String, repository: String, event: WebHook.Event)(implicit s: Session): List[WebHook] =
-    WebHookEvents.filter(t => t.byRepository(owner, repository) && t.event === event.bind)
-      .list.map(t => WebHook(t.userName, t.repositoryName, t.url))
+     WebHooks.filter(_.byRepository(owner, repository))
+       .innerJoin(WebHookEvents).on { (wh, whe) => whe.byWebHook(wh) }
+       .filter{ case (wh, whe) => whe.event === event.bind}
+       .map{ case (wh, whe) => wh }
+       .list.distinct
 
   /** get All WebHook information from repository to url */
   def getWebHook(owner: String, repository: String, url: String)(implicit s: Session): Option[(WebHook, Set[WebHook.Event])] =
@@ -44,14 +52,15 @@ trait WebHookService {
       .map{ case (w,t) => w -> t.event }
       .list.groupBy(_._1).mapValues(_.map(_._2).toSet).headOption
 
-  def addWebHook(owner: String, repository: String, url :String, events: Set[WebHook.Event])(implicit s: Session): Unit = {
-    WebHooks insert WebHook(owner, repository, url)
+  def addWebHook(owner: String, repository: String, url :String, events: Set[WebHook.Event], ctype: WebHookContentType,  token: Option[String])(implicit s: Session): Unit = {
+    WebHooks insert WebHook(owner, repository, url, ctype, token)
     events.toSet.map{ event: WebHook.Event =>
       WebHookEvents insert WebHookEvent(owner, repository, url, event)
     }
   }
 
-  def updateWebHook(owner: String, repository: String, url :String, events: Set[WebHook.Event])(implicit s: Session): Unit = {
+  def updateWebHook(owner: String, repository: String, url :String, events: Set[WebHook.Event], ctype: WebHookContentType, token: Option[String])(implicit s: Session): Unit = {
+    WebHooks.filter(_.byPrimaryKey(owner, repository, url)).map(w => (w.ctype, w.token)).update((ctype, token))
     WebHookEvents.filter(_.byWebHook(owner, repository, url)).delete
     events.toSet.map{ event: WebHook.Event =>
       WebHookEvents insert WebHookEvent(owner, repository, url, event)
@@ -69,17 +78,17 @@ trait WebHookService {
     }
   }
 
-  def callWebHook(event: WebHook.Event, webHookURLs: List[WebHook], payload: WebHookPayload)
+  def callWebHook(event: WebHook.Event, webHooks: List[WebHook], payload: WebHookPayload)
                  (implicit c: JsonFormat.Context): List[(WebHook, String, Future[HttpRequest], Future[HttpResponse])] = {
     import org.apache.http.impl.client.HttpClientBuilder
     import ExecutionContext.Implicits.global
     import org.apache.http.protocol.HttpContext
     import org.apache.http.client.methods.HttpPost
 
-    if(webHookURLs.nonEmpty){
+    if(webHooks.nonEmpty){
       val json = JsonFormat(payload)
 
-      webHookURLs.map { webHookUrl =>
+      webHooks.map { webHook =>
         val reqPromise = Promise[HttpRequest]
         val f = Future {
           val itcp = new org.apache.http.HttpRequestInterceptor{
@@ -89,19 +98,36 @@ trait WebHookService {
           }
           try{
             val httpClient = HttpClientBuilder.create.addInterceptorLast(itcp).build
-            logger.debug(s"start web hook invocation for ${webHookUrl.url}")
-            val httpPost = new HttpPost(webHookUrl.url)
-            httpPost.addHeader("Content-Type", "application/x-www-form-urlencoded")
+            logger.debug(s"start web hook invocation for ${webHook.url}")
+            val httpPost = new HttpPost(webHook.url)
+            logger.info(s"Content-Type: ${webHook.ctype.ctype}")
+            httpPost.addHeader("Content-Type", webHook.ctype.ctype)
             httpPost.addHeader("X-Github-Event", event.name)
             httpPost.addHeader("X-Github-Delivery", java.util.UUID.randomUUID().toString)
 
-            val params: java.util.List[NameValuePair] = new java.util.ArrayList()
-            params.add(new BasicNameValuePair("payload", json))
-            httpPost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"))
+            webHook.ctype match {
+              case WebHookContentType.FORM => {
+            	  val params: java.util.List[NameValuePair] = new java.util.ArrayList()
+                params.add(new BasicNameValuePair("payload", json))
+                def postContent = new UrlEncodedFormEntity(params, "UTF-8")
+                httpPost.setEntity(postContent)
+                if (webHook.token.exists(_.trim.nonEmpty)) {
+                  // TODO find a better way and see how to extract content from postContent
+                  val contentAsBytes = URLEncodedUtils.format(params, "UTF-8").getBytes("UTF-8")
+                  httpPost.addHeader("X-Hub-Signature", XHub.generateHeaderXHubToken(XHubConverter.HEXA_LOWERCASE, XHubDigest.SHA1, webHook.token.get, contentAsBytes))
+                }
+              }
+              case WebHookContentType.JSON => {
+            	  httpPost.setEntity(EntityBuilder.create().setText(json).build())
+                if (!webHook.token.isEmpty) {
+                  httpPost.addHeader("X-Hub-Signature", XHub.generateHeaderXHubToken(XHubConverter.HEXA_LOWERCASE, XHubDigest.SHA1, webHook.token.orNull, json.getBytes("UTF-8")))
+                }
+              }
+            }
 
             val res = httpClient.execute(httpPost)
             httpPost.releaseConnection()
-            logger.debug(s"end web hook invocation for ${webHookUrl}")
+            logger.debug(s"end web hook invocation for ${webHook}")
             res
           }catch{
             case e:Throwable => {
@@ -113,12 +139,12 @@ trait WebHookService {
           }
         }
         f.onSuccess {
-          case s => logger.debug(s"Success: web hook request to ${webHookUrl.url}")
+          case s => logger.debug(s"Success: web hook request to ${webHook.url}")
         }
         f.onFailure {
-          case t => logger.error(s"Failed: web hook request to ${webHookUrl.url}", t)
+          case t => logger.error(s"Failed: web hook request to ${webHook.url}", t)
         }
-        (webHookUrl, json, reqPromise.future, f)
+        (webHook, json, reqPromise.future, f)
       }
     } else {
       Nil
@@ -161,7 +187,7 @@ trait WebHookPullRequestService extends WebHookService {
         baseOwner <- users.get(repository.owner)
         headOwner <- users.get(pullRequest.requestUserName)
         issueUser <- users.get(issue.openedUserName)
-        headRepo  <- getRepository(pullRequest.requestUserName, pullRequest.requestRepositoryName, baseUrl)
+        headRepo  <- getRepository(pullRequest.requestUserName, pullRequest.requestRepositoryName)
       } yield {
         WebHookPullRequestPayload(
           action         = action,
@@ -200,7 +226,7 @@ trait WebHookPullRequestService extends WebHookService {
     import WebHookService._
     for{
       ((issue, issueUser, pullRequest, baseOwner, headOwner), webHooks) <- getPullRequestsByRequestForWebhook(requestRepository.owner, requestRepository.name, requestBranch)
-      baseRepo <- getRepository(pullRequest.userName, pullRequest.repositoryName, baseUrl)
+      baseRepo <- getRepository(pullRequest.userName, pullRequest.repositoryName)
     } yield {
       val payload = WebHookPullRequestPayload(
         action         = action,
@@ -229,7 +255,7 @@ trait WebHookPullRequestReviewCommentService extends WebHookService {
         baseOwner <- users.get(repository.owner)
         headOwner <- users.get(pullRequest.requestUserName)
         issueUser <- users.get(issue.openedUserName)
-        headRepo  <- getRepository(pullRequest.requestUserName, pullRequest.requestRepositoryName, baseUrl)
+        headRepo  <- getRepository(pullRequest.requestUserName, pullRequest.requestRepositoryName)
       } yield {
         WebHookPullRequestReviewCommentPayload(
           action         = action,

src/main/scala/gitbucket/core/service/WikiService.scala

@@ -1,7 +1,9 @@
 package gitbucket.core.service
 
 import java.util.Date
+import gitbucket.core.controller.Context
 import gitbucket.core.model.Account
+import gitbucket.core.service.RepositoryService.RepositoryInfo
 import gitbucket.core.util._
 import gitbucket.core.util.ControlUtil._
 import org.eclipse.jgit.api.Git
@@ -13,7 +15,6 @@ import java.io.ByteArrayInputStream
 import org.eclipse.jgit.patch._
 import org.eclipse.jgit.api.errors.PatchFormatException
 import scala.collection.JavaConverters._
-import RepositoryService.RepositoryInfo
 
 object WikiService {
   
@@ -38,10 +39,13 @@ object WikiService {
    */
   case class WikiPageHistoryInfo(name: String, committer: String, message: String, date: Date)
 
-  def httpUrl(repository: RepositoryInfo) = repository.httpUrl.replaceFirst("\\.git\\Z", ".wiki.git")
 
-  def sshUrl(repository: RepositoryInfo, settings: SystemSettingsService.SystemSettings, userName: String) =
-    repository.sshUrl(settings.sshPort.getOrElse(SystemSettingsService.DefaultSshPort), userName).replaceFirst("\\.git\\Z", ".wiki.git")
+  def wikiHttpUrl(repositoryInfo: RepositoryInfo)(implicit context: Context): String
+    = RepositoryService.httpUrl(repositoryInfo.owner, repositoryInfo.name + ".wiki")
+
+  def wikiSshUrl(repositoryInfo: RepositoryInfo)(implicit context: Context): Option[String]
+    = RepositoryService.sshUrl(repositoryInfo.owner, repositoryInfo.name + ".wiki")
+
 }
 
 trait WikiService {
@@ -93,7 +97,7 @@ trait WikiService {
   def getWikiPageList(owner: String, repository: String): List[String] = {
     using(Git.open(Directory.getWikiRepositoryDir(owner, repository))){ git =>
       JGitUtil.getFileList(git, "master", ".")
-        .filter(_.name.endsWith(".md"))
+        .filter(_.name.endsWith(".md")).filterNot(_.name.startsWith("_"))
         .map(_.name.stripSuffix(".md"))
         .sortBy(x => x)
     }

src/main/scala/gitbucket/core/servlet/AutoUpdate.scala

@@ -18,9 +18,14 @@ import gitbucket.core.util.Directory
 object AutoUpdate {
 
   /**
-   * The history of versions. A head of this sequence is the current BitBucket version.
+   * The history of versions. A head of this sequence is the current GitBucket version.
    */
   val versions = Seq(
+    new Version(3, 14),
+    new Version(3, 13),
+    new Version(3, 12),
+    new Version(3, 11),
+    new Version(3, 10),
     new Version(3, 9),
     new Version(3, 8),
     new Version(3, 7) with SystemSettingsService {
@@ -154,7 +159,7 @@ object AutoUpdate {
   )
 
   /**
-   * The head version of BitBucket.
+   * The head version of GitBucket.
    */
   val headVersion = versions.head
 

src/main/scala/gitbucket/core/servlet/BasicAuthenticationFilter.scala

@@ -74,7 +74,7 @@ class BasicAuthenticationFilter extends Filter with RepositoryService with Accou
 
     request.paths match {
       case Array(_, repositoryOwner, repositoryName, _*) =>
-        getRepository(repositoryOwner, repositoryName.replaceFirst("\\.wiki\\.git$|\\.git$", ""), "") match {
+        getRepository(repositoryOwner, repositoryName.replaceFirst("\\.wiki\\.git$|\\.git$", "")) match {
           case Some(repository) => {
             if(!isUpdating && !repository.repository.isPrivate && settings.allowAnonymousAccess){
               chain.doFilter(request, response)

src/main/scala/gitbucket/core/servlet/GitRepositoryServlet.scala

@@ -10,7 +10,6 @@ import gitbucket.core.service.WebHookService._
 import gitbucket.core.service._
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Implicits._
-import gitbucket.core.util.JGitUtil.CommitInfo
 import gitbucket.core.util._
 
 import org.eclipse.jgit.api.Git
@@ -111,13 +110,21 @@ import scala.collection.JavaConverters._
 class CommitLogHook(owner: String, repository: String, pusher: String, baseUrl: String)(implicit session: Session)
   extends PostReceiveHook with PreReceiveHook
   with RepositoryService with AccountService with IssuesService with ActivityService with PullRequestService with WebHookService
-  with WebHookPullRequestService {
+  with WebHookPullRequestService with ProtectedBranchService {
   
   private val logger = LoggerFactory.getLogger(classOf[CommitLogHook])
   private var existIds: Seq[String] = Nil
 
   def onPreReceive(receivePack: ReceivePack, commands: java.util.Collection[ReceiveCommand]): Unit = {
     try {
+      commands.asScala.foreach { command =>
+        // call pre-commit hook
+        PluginRegistry().getReceiveHooks
+          .flatMap(_.preReceive(owner, repository, receivePack, command, pusher))
+          .headOption.foreach { error =>
+          command.setResult(ReceiveCommand.Result.REJECTED_OTHER_REASON, error)
+        }
+      }
       using(Git.open(Directory.getRepositoryDir(owner, repository))) { git =>
         existIds = JGitUtil.getAllCommitIds(git)
       }
@@ -152,7 +159,7 @@ class CommitLogHook(owner: String, repository: String, pusher: String, baseUrl:
             countIssue(IssueSearchCondition(state = "open"), false, owner -> repository) +
             countIssue(IssueSearchCondition(state = "closed"), false, owner -> repository)
 
-          val repositoryInfo = getRepository(owner, repository, baseUrl).get
+          val repositoryInfo = getRepository(owner, repository).get
 
           // Extract new commit and apply issue comment
           val defaultBranch = repositoryInfo.repository.defaultBranch
@@ -160,7 +167,7 @@ class CommitLogHook(owner: String, repository: String, pusher: String, baseUrl:
             if (!existIds.contains(commit.id) && !pushedIds.contains(commit.id)) {
               if (issueCount > 0) {
                 pushedIds.add(commit.id)
-                createIssueComment(commit)
+                createIssueComment(owner, repository, commit)
                 // close issues
                 if(refName(1) == "heads" && branchName == defaultBranch && command.getType == ReceiveCommand.Type.UPDATE){
                   closeIssuesFromMessage(commit.fullMessage, pusher, owner, repository)
@@ -207,6 +214,9 @@ class CommitLogHook(owner: String, repository: String, pusher: String, baseUrl:
                                  newId = command.getNewId(), oldId = command.getOldId())
             }
           }
+
+          // call post-commit hook
+          PluginRegistry().getReceiveHooks.foreach(_.postReceive(owner, repository, receivePack, command, pusher))
         }
       }
       // update repository last modified time.
@@ -219,13 +229,4 @@ class CommitLogHook(owner: String, repository: String, pusher: String, baseUrl:
     }
   }
 
-  private def createIssueComment(commit: CommitInfo) = {
-    StringUtil.extractIssueId(commit.fullMessage).foreach { issueId =>
-      if(getIssue(owner, repository, issueId).isDefined){
-        getAccountByMailAddress(commit.committerEmailAddress).foreach { account =>
-          createComment(owner, repository, account.userName, issueId.toInt, commit.fullMessage + " " + commit.id, "commit")
-        }
-      }
-    }
-  }
 }

src/main/scala/gitbucket/core/ssh/GitCommand.scala

@@ -23,10 +23,10 @@ object GitCommand {
 abstract class GitCommand() extends Command {
 
   private val logger = LoggerFactory.getLogger(classOf[GitCommand])
-  protected var err: OutputStream = null
-  protected var in: InputStream = null
-  protected var out: OutputStream = null
-  protected var callback: ExitCallback = null
+  @volatile protected var err: OutputStream = null
+  @volatile protected var in: InputStream = null
+  @volatile protected var out: OutputStream = null
+  @volatile protected var callback: ExitCallback = null
 
   protected def runTask(user: String)(implicit session: Session): Unit
 
@@ -87,11 +87,11 @@ abstract class DefaultGitCommand(val owner: String, val repoName: String) extend
 }
 
 
-class DefaultGitUploadPack(owner: String, repoName: String, baseUrl: String) extends DefaultGitCommand(owner, repoName)
+class DefaultGitUploadPack(owner: String, repoName: String) extends DefaultGitCommand(owner, repoName)
     with RepositoryService with AccountService {
 
   override protected def runTask(user: String)(implicit session: Session): Unit = {
-    getRepository(owner, repoName.replaceFirst("\\.wiki\\Z", ""), baseUrl).foreach { repositoryInfo =>
+    getRepository(owner, repoName.replaceFirst("\\.wiki\\Z", "")).foreach { repositoryInfo =>
       if(!repositoryInfo.repository.isPrivate || isWritableUser(user, repositoryInfo)){
         using(Git.open(getRepositoryDir(owner, repoName))) { git =>
           val repository = git.getRepository
@@ -107,7 +107,7 @@ class DefaultGitReceivePack(owner: String, repoName: String, baseUrl: String) ex
     with RepositoryService with AccountService {
 
   override protected def runTask(user: String)(implicit session: Session): Unit = {
-    getRepository(owner, repoName.replaceFirst("\\.wiki\\Z", ""), baseUrl).foreach { repositoryInfo =>
+    getRepository(owner, repoName.replaceFirst("\\.wiki\\Z", "")).foreach { repositoryInfo =>
       if(isWritableUser(user, repositoryInfo)){
         using(Git.open(getRepositoryDir(owner, repoName))) { git =>
           val repository = git.getRepository
@@ -124,7 +124,7 @@ class DefaultGitReceivePack(owner: String, repoName: String, baseUrl: String) ex
   }
 }
 
-class PluginGitUploadPack(repoName: String, baseUrl: String, routing: GitRepositoryRouting) extends GitCommand
+class PluginGitUploadPack(repoName: String, routing: GitRepositoryRouting) extends GitCommand
     with SystemSettingsService {
 
   override protected def runTask(user: String)(implicit session: Session): Unit = {
@@ -139,7 +139,7 @@ class PluginGitUploadPack(repoName: String, baseUrl: String, routing: GitReposit
   }
 }
 
-class PluginGitReceivePack(repoName: String, baseUrl: String, routing: GitRepositoryRouting) extends GitCommand
+class PluginGitReceivePack(repoName: String, routing: GitRepositoryRouting) extends GitCommand
     with SystemSettingsService {
 
   override protected def runTask(user: String)(implicit session: Session): Unit = {
@@ -163,9 +163,9 @@ class GitCommandFactory(baseUrl: String) extends CommandFactory {
     logger.debug(s"command: $command")
 
     command match {
-      case SimpleCommandRegex ("upload" , repoName) if(pluginRepository(repoName)) => new PluginGitUploadPack (repoName, baseUrl, routing(repoName))
-      case SimpleCommandRegex ("receive", repoName) if(pluginRepository(repoName)) => new PluginGitReceivePack(repoName, baseUrl, routing(repoName))
-      case DefaultCommandRegex("upload" , owner, repoName) => new DefaultGitUploadPack (owner, repoName, baseUrl)
+      case SimpleCommandRegex ("upload" , repoName) if(pluginRepository(repoName)) => new PluginGitUploadPack (repoName, routing(repoName))
+      case SimpleCommandRegex ("receive", repoName) if(pluginRepository(repoName)) => new PluginGitReceivePack(repoName, routing(repoName))
+      case DefaultCommandRegex("upload" , owner, repoName) => new DefaultGitUploadPack (owner, repoName)
       case DefaultCommandRegex("receive", owner, repoName) => new DefaultGitReceivePack(owner, repoName, baseUrl)
       case _ => new UnknownCommand(command)
     }

src/main/scala/gitbucket/core/ssh/NoShell.scala

@@ -1,12 +1,13 @@
 package gitbucket.core.ssh
 
 import gitbucket.core.service.SystemSettingsService
+import gitbucket.core.service.SystemSettingsService.SshAddress
 import org.apache.sshd.common.Factory
 import org.apache.sshd.server.{Environment, ExitCallback, Command}
 import java.io.{OutputStream, InputStream}
 import org.eclipse.jgit.lib.Constants
 
-class NoShell extends Factory[Command] with SystemSettingsService {
+class NoShell(sshAddress:SshAddress) extends Factory[Command] {
   override def create(): Command = new Command() {
     private var in: InputStream = null
     private var out: OutputStream = null
@@ -15,7 +16,6 @@ class NoShell extends Factory[Command] with SystemSettingsService {
 
     override def start(env: Environment): Unit = {
       val user = env.getEnv.get("USER")
-      val port = loadSystemSettings().sshPort.getOrElse(SystemSettingsService.DefaultSshPort)
       val message =
         """
           | Welcome to
@@ -31,8 +31,8 @@ class NoShell extends Factory[Command] with SystemSettingsService {
           |
           | Please use:
           |
-          | git clone ssh://%s@GITBUCKET_HOST:%d/OWNER/REPOSITORY_NAME.git
-        """.stripMargin.format(user, port).replace("\n", "\r\n") + "\r\n"
+          | git clone ssh://%s@%s:%d/OWNER/REPOSITORY_NAME.git
+        """.stripMargin.format(user, sshAddress.host, sshAddress.port).replace("\n", "\r\n") + "\r\n"
       err.write(Constants.encode(message))
       err.flush()
       in.close()

src/main/scala/gitbucket/core/ssh/SshServerListener.scala

@@ -5,7 +5,8 @@ import java.util.concurrent.atomic.AtomicBoolean
 import javax.servlet.{ServletContextEvent, ServletContextListener}
 
 import gitbucket.core.service.SystemSettingsService
-import gitbucket.core.util.Directory
+import gitbucket.core.service.SystemSettingsService.SshAddress
+import gitbucket.core.util.{Directory}
 import org.apache.sshd.server.keyprovider.SimpleGeneratorHostKeyProvider
 import org.slf4j.LoggerFactory
 
@@ -14,20 +15,20 @@ object SshServer {
   private val server = org.apache.sshd.server.SshServer.setUpDefaultServer()
   private val active = new AtomicBoolean(false)
 
-  private def configure(port: Int, baseUrl: String) = {
-    server.setPort(port)
+  private def configure(sshAddress: SshAddress, baseUrl: String) = {
+    server.setPort(sshAddress.port)
     val provider = new SimpleGeneratorHostKeyProvider(new File(s"${Directory.GitBucketHome}/gitbucket.ser"))
     provider.setAlgorithm("RSA")
     provider.setOverwriteAllowed(false)
     server.setKeyPairProvider(provider)
     server.setPublickeyAuthenticator(new PublicKeyAuthenticator)
     server.setCommandFactory(new GitCommandFactory(baseUrl))
-    server.setShellFactory(new NoShell)
+    server.setShellFactory(new NoShell(sshAddress))
   }
 
-  def start(port: Int, baseUrl: String) = {
+  def start(sshAddress: SshAddress, baseUrl: String) = {
     if(active.compareAndSet(false, true)){
-      configure(port, baseUrl)
+      configure(sshAddress, baseUrl)
       server.start()
       logger.info(s"Start SSH Server Listen on ${server.getPort}")
     }
@@ -55,20 +56,18 @@ class SshServerListener extends ServletContextListener with SystemSettingsServic
 
   override def contextInitialized(sce: ServletContextEvent): Unit = {
     val settings = loadSystemSettings()
-    if(settings.ssh){
-      settings.baseUrl match {
-        case None =>
-          logger.error("Could not start SshServer because the baseUrl is not configured.")
-        case Some(baseUrl) =>
-          SshServer.start(settings.sshPort.getOrElse(SystemSettingsService.DefaultSshPort), baseUrl)
-      }
+    if (settings.sshAddress.isDefined && settings.baseUrl.isEmpty) {
+    	logger.error("Could not start SshServer because the baseUrl is not configured.")
     }
+    for {
+      sshAddress <- settings.sshAddress
+      baseUrl    <- settings.baseUrl
+    }
+    SshServer.start(sshAddress, baseUrl)
   }
 
   override def contextDestroyed(sce: ServletContextEvent): Unit = {
-    if(loadSystemSettings().ssh){
-      SshServer.stop()
-    }
+    SshServer.stop()
   }
 
 }

src/main/scala/gitbucket/core/util/Authenticator.scala

@@ -36,7 +36,7 @@ trait OwnerAuthenticator { self: ControllerBase with RepositoryService with Acco
   private def authenticate(action: (RepositoryInfo) => Any) = {
     {
       defining(request.paths){ paths =>
-        getRepository(paths(0), paths(1), baseUrl).map { repository =>
+        getRepository(paths(0), paths(1)).map { repository =>
           context.loginAccount match {
             case Some(x) if(x.isAdmin) => action(repository)
             case Some(x) if(repository.owner == x.userName) => action(repository)
@@ -95,7 +95,7 @@ trait CollaboratorsAuthenticator { self: ControllerBase with RepositoryService =
   private def authenticate(action: (RepositoryInfo) => Any) = {
     {
       defining(request.paths){ paths =>
-        getRepository(paths(0), paths(1), baseUrl).map { repository =>
+        getRepository(paths(0), paths(1)).map { repository =>
           context.loginAccount match {
             case Some(x) if(x.isAdmin) => action(repository)
             case Some(x) if(paths(0) == x.userName) => action(repository)
@@ -118,7 +118,7 @@ trait ReferrerAuthenticator { self: ControllerBase with RepositoryService =>
   private def authenticate(action: (RepositoryInfo) => Any) = {
     {
       defining(request.paths){ paths =>
-        getRepository(paths(0), paths(1), baseUrl).map { repository =>
+        getRepository(paths(0), paths(1)).map { repository =>
           if(!repository.repository.isPrivate){
             action(repository)
           } else {
@@ -145,7 +145,7 @@ trait ReadableUsersAuthenticator { self: ControllerBase with RepositoryService =
   private def authenticate(action: (RepositoryInfo) => Any) = {
     {
       defining(request.paths){ paths =>
-        getRepository(paths(0), paths(1), baseUrl).map { repository =>
+        getRepository(paths(0), paths(1)).map { repository =>
           context.loginAccount match {
             case Some(x) if(x.isAdmin) => action(repository)
             case Some(x) if(!repository.repository.isPrivate) => action(repository)

src/main/scala/gitbucket/core/util/ControlUtil.scala

@@ -1,8 +1,6 @@
 package gitbucket.core.util
 
 import org.eclipse.jgit.api.Git
-import org.eclipse.jgit.revwalk.RevWalk
-import org.eclipse.jgit.treewalk.TreeWalk
 import scala.util.control.Exception._
 import scala.language.reflectiveCalls
 
@@ -31,12 +29,6 @@ object ControlUtil {
       git2.getRepository.close()
     }
 
-  def using[T](revWalk: RevWalk)(f: RevWalk => T): T =
-    try f(revWalk) finally revWalk.release()
-
-  def using[T](treeWalk: TreeWalk)(f: TreeWalk => T): T =
-    try f(treeWalk) finally treeWalk.release()
-
   def ignore[T](f: => Unit): Unit = try {
     f
   } catch {

src/main/scala/gitbucket/core/util/Implicits.scala

@@ -75,6 +75,11 @@ object Implicits {
 
     def gitRepositoryPath: String = request.getRequestURI.replaceFirst("^/git/", "/")
 
+    def baseUrl:String = {
+      val url = request.getRequestURL.toString
+      val len = url.length - (request.getRequestURI.length - request.getContextPath.length)
+      url.substring(0, len).stripSuffix("/")
+    }
   }
 
   implicit class RichSession(session: HttpSession){

src/main/scala/gitbucket/core/util/JGitUtil.scala

@@ -32,14 +32,13 @@ object JGitUtil {
    *
    * @param owner the user name of the repository owner
    * @param name the repository name
-   * @param url the repository URL
    * @param commitCount the commit count. If the repository has over 1000 commits then this property is 1001.
    * @param branchList the list of branch names
    * @param tags the list of tags
    */
-  case class RepositoryInfo(owner: String, name: String, url: String, commitCount: Int, branchList: List[String], tags: List[TagInfo]){
-    def this(owner: String, name: String, baseUrl: String) = {
-      this(owner, name, s"${baseUrl}/git/${owner}/${name}.git", 0, Nil, Nil)
+  case class RepositoryInfo(owner: String, name: String, commitCount: Int, branchList: List[String], tags: List[TagInfo]){
+    def this(owner: String, name: String) = {
+      this(owner, name, 0, Nil, Nil)
     }
   }
 
@@ -110,6 +109,8 @@ object JGitUtil {
     newIsImage: Boolean,
     oldObjectId: Option[String],
     newObjectId: Option[String],
+    oldMode: String,
+    newMode: String,
     tooLarge: Boolean
   )
 
@@ -172,14 +173,14 @@ object JGitUtil {
   /**
    * Returns the repository information. It contains branch names and tag names.
    */
-  def getRepositoryInfo(owner: String, repository: String, baseUrl: String): RepositoryInfo = {
+  def getRepositoryInfo(owner: String, repository: String): RepositoryInfo = {
     using(Git.open(getRepositoryDir(owner, repository))){ git =>
       try {
         // get commit count
         val commitCount = git.log.all.call.iterator.asScala.map(_ => 1).take(10001).sum
 
         RepositoryInfo(
-          owner, repository, s"${baseUrl}/git/${owner}/${repository}.git",
+          owner, repository,
           // commit count
           commitCount,
           // branches
@@ -195,7 +196,7 @@ object JGitUtil {
       } catch {
         // not initialized
         case e: NoHeadException => RepositoryInfo(
-          owner, repository, s"${baseUrl}/git/${owner}/${repository}.git", 0, Nil, Nil)
+          owner, repository, 0, Nil, Nil)
 
       }
     }
@@ -515,6 +516,8 @@ object JGitUtil {
                 newIsImage  = newIsImage,
                 oldObjectId = None,
                 newObjectId = Option(treeWalk.getObjectId(0)).map(_.name),
+                oldMode     = treeWalk.getFileMode(0).toString,
+                newMode     = treeWalk.getFileMode(0).toString,
                 tooLarge    = false
               )
             } else {
@@ -528,6 +531,8 @@ object JGitUtil {
                 newIsImage  = newIsImage,
                 oldObjectId = None,
                 newObjectId = Option(treeWalk.getObjectId(0)).map(_.name),
+                oldMode     = treeWalk.getFileMode(0).toString,
+                newMode     = treeWalk.getFileMode(0).toString,
                 tooLarge    = false
               )
             }))
@@ -562,6 +567,8 @@ object JGitUtil {
           newIsImage  = false,
           oldObjectId = Option(diff.getOldId).map(_.name),
           newObjectId = Option(diff.getNewId).map(_.name),
+          oldMode     = diff.getOldMode.toString,
+          newMode     = diff.getNewMode.toString,
           tooLarge    = true
         )
       } else {
@@ -578,6 +585,8 @@ object JGitUtil {
             newIsImage  = newIsImage,
             oldObjectId = Option(diff.getOldId).map(_.name),
             newObjectId = Option(diff.getNewId).map(_.name),
+            oldMode     = diff.getOldMode.toString,
+            newMode     = diff.getNewMode.toString,
             tooLarge    = false
           )
         } else {
@@ -591,6 +600,8 @@ object JGitUtil {
             newIsImage  = newIsImage,
             oldObjectId = Option(diff.getOldId).map(_.name),
             newObjectId = Option(diff.getNewId).map(_.name),
+            oldMode     = diff.getOldMode.toString,
+            newMode     = diff.getNewMode.toString,
             tooLarge    = false
           )
         }
@@ -629,7 +640,7 @@ object JGitUtil {
 
   def initRepository(dir: java.io.File): Unit =
     using(new RepositoryBuilder().setGitDir(dir).setBare.build){ repository =>
-      repository.create
+      repository.create(true)
       setReceivePack(repository)
     }
 
@@ -688,7 +699,7 @@ object JGitUtil {
 
     val newHeadId = inserter.insert(newCommit)
     inserter.flush()
-    inserter.release()
+    inserter.close()
 
     val refUpdate = git.getRepository.updateRef(ref)
     refUpdate.setNewObjectId(newHeadId)

src/main/scala/gitbucket/core/util/Validations.scala

@@ -1,6 +1,6 @@
 package gitbucket.core.util
 
-import jp.sf.amateras.scalatra.forms._
+import io.github.gitbucket.scalatra.forms._
 import org.scalatra.i18n.Messages
 
 trait Validations {

src/main/scala/gitbucket/core/view/Markdown.scala

@@ -33,28 +33,30 @@ object Markdown {
              enableTaskList: Boolean = false,
              hasWritePermission: Boolean = false,
              pages: List[String] = Nil)(implicit context: Context): String = {
-    // escape issue id
-    val s = if(enableRefsLink){
-      markdown.replaceAll("(?<=(\\W|^))#(\\d+)(?=(\\W|$))", "issue:$2")
-    } else markdown
 
     // escape task list
-    val source = if(enableTaskList){
-      escapeTaskList(s)
-    } else s
+    val source = if(enableTaskList) escapeTaskList(markdown) else markdown
 
     val options = new Options()
     options.setSanitize(true)
     options.setBreaks(enableLineBreaks)
-    val renderer = new GitBucketMarkedRenderer(options, repository, enableWikiLink, enableRefsLink, enableAnchor, enableTaskList, hasWritePermission, pages)
+
+    val renderer = new GitBucketMarkedRenderer(options, repository,
+      enableWikiLink, enableRefsLink, enableAnchor, enableTaskList, hasWritePermission, pages)
+
     Marked.marked(source, options, renderer)
   }
 
   /**
    * Extends markedj Renderer for GitBucket
    */
-  class GitBucketMarkedRenderer(options: Options, repository: RepositoryService.RepositoryInfo,
-                                enableWikiLink: Boolean, enableRefsLink: Boolean, enableAnchor: Boolean, enableTaskList: Boolean, hasWritePermission: Boolean,
+  class GitBucketMarkedRenderer(options: Options,
+                                repository: RepositoryService.RepositoryInfo,
+                                enableWikiLink: Boolean,
+                                enableRefsLink: Boolean,
+                                enableAnchor: Boolean,
+                                enableTaskList: Boolean,
+                                hasWritePermission: Boolean,
                                 pages: List[String])
                                (implicit val context: Context) extends Renderer(options) with LinkConverter with RequestCache {
 
@@ -62,11 +64,14 @@ object Markdown {
       val id = generateAnchorName(text)
       val out = new StringBuilder()
 
-      out.append("<h" + level + " id=\"" + options.getHeaderPrefix + id + "\" class=\"markdown-head\">")
+      out.append("<h" + level + " id=\"" + options.getHeaderPrefix + id + "\"")
 
       if(enableAnchor){
-        out.append("<a class=\"markdown-anchor-link\" href=\"#" + id + "\"></a>")
+        out.append(" class=\"markdown-head\">")
+        out.append("<a class=\"markdown-anchor-link\" href=\"#" + id + "\"><span class=\"octicon octicon-link\"></span></a>")
         out.append("<a class=\"markdown-anchor\" name=\"" + id + "\"></a>")
+      } else {
+        out.append(">")
       }
 
       out.append(text)
@@ -83,28 +88,27 @@ object Markdown {
       var listType: String = null
       if (ordered) {
         listType = "ol"
-      }
-      else {
+      } else {
         listType = "ul"
       }
       if(body.contains("""class="task-list-item-checkbox"""")){
-        return "<" + listType + " class=\"task-list\">\n" + body + "</" + listType + ">\n"
+        "<" + listType + " class=\"task-list\">\n" + body + "</" + listType + ">\n"
       } else {
-        return "<" + listType + ">\n" + body + "</" + listType + ">\n"
+        "<" + listType + ">\n" + body + "</" + listType + ">\n"
       }
     }
 
     override def listitem(text: String): String = {
       if(text.contains("""class="task-list-item-checkbox" """)){
-        return "<li class=\"task-list-item\">" + text + "</li>\n"
+        "<li class=\"task-list-item\">" + text + "</li>\n"
       } else {
-        return "<li>" + text + "</li>\n"
+        "<li>" + text + "</li>\n"
       }
     }
 
     override def text(text: String): String = {
       // convert commit id and username to link.
-      val t1 = if(enableRefsLink) convertRefsLinks(text, repository, "issue:", false) else text
+      val t1 = if(enableRefsLink) convertRefsLinks(text, repository, "#", false) else text
 
       // convert task list to checkbox.
       val t2 = if(enableTaskList) convertCheckBox(t1, hasWritePermission) else t1