Merge branch 'master' into feature/blame

Conflicts: src/main/scala/gitbucket/core/util/JGitUtil.scala
2026-05-07 00:05:55 +02:00 · 2015-03-28 21:19:40 +09:00
parent 83fd2648f5 73766f11eb
commit d8d18ed25c
114 changed files with 3738 additions and 673 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,3 +1,3 @@
 language: scala
 scala:
-  - 2.11.2
+  - 2.11.6
--- a/build.xml
+++ b/build.xml
@@ -6,7 +6,7 @@
  <property name="jetty.dir" value="embed-jetty"/>
  <property name="scala.version" value="2.11"/>
  <property name="gitbucket.version" value="3.0.0"/>
-  <property name="jetty.version" value="8.1.8.v20121106"/>
+  <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">
--- a/doc/activity.md
+++ b/doc/activity.md
@@ -0,0 +1,22 @@
+Activity Timeline
+========
+GitBucket records several types of user activity to ```ACTIVITY``` table. Activity types are shown below:
+
+type              | message                                              | additional information
+------------------|------------------------------------------------------|------------------------
+create_repository |$user created $owner/$repo                            |-
+open_issue        |$user opened issue $owner/$repo#$issueId              |-
+close_issue       |$user closed issue $owner/$repo#$issueId              |-
+close_issue       |$user closed pull request $owner/$repo#$issueId       |-
+reopen_issue      |$user reopened issue $owner/$repo#$issueId            |-
+comment_issue     |$user commented on issue $owner/$repo#$issueId        |-
+comment_issue     |$user commented on pull request $owner/$repo#$issueId |-
+create_wiki       |$user created the $owner/$repo wiki                   |$page
+edit_wiki         |$user edited the $owner/$repo wiki                    |$page<br>$page:$commitId(since 1.5)
+push              |$user pushed to $owner/$repo#$branch to $owner/$repo  |$commitId:$shortMessage\n*
+create_tag        |$user created tag $tag at $owner/$repo                |-
+create_branch     |$user created branch $branch at $owner/$repo          |-
+delete_branch     |$user deleted branch $branch at $owner/$repo          |-
+fork              |$user forked $owner/$repo to $owner/$repo             |-
+open_pullreq      |$user opened pull request $owner/$repo#issueId        |-
+merge_pullreq     |$user merge pull request $owner/$repo#issueId         |-
--- a/doc/auto_update.md
+++ b/doc/auto_update.md
@@ -0,0 +1,37 @@
+Automatic Schema Updating
+========
+GitBucket uses H2 database to manage project and account data. GitBucket updates database schema automatically in the first run after the upgrading.
+
+To release a new version of GitBucket, add the version definition to the [servlet.AutoUpdate](https://github.com/takezoe/gitbucket/blob/master/src/main/scala/servlet/AutoUpdateListener.scala) at first.
+
+```scala
+object AutoUpdate {
+  ...
+  /**
+   * The history of versions. A head of this sequence is the current BitBucket version.
+   */
+  val versions = Seq(
+      Version(1, 0)
+  )
+  ...
+```
+
+Next, add a SQL file which updates database schema into [/src/main/resources/update/](https://github.com/takezoe/gitbucket/tree/master/src/main/resources/update) as ```MAJOR_MINOR.sql```.
+
+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:
+
+```scala
+val versions = Seq(
+  new Version(1, 3){
+    override def update(conn: Connection): Unit = {
+      super.update(conn)
+      // Add any code here!
+    }
+  },
+  Version(1, 2),
+  Version(1, 1),
+  Version(1, 0)
+)
+```
--- a/doc/comment_action.md
+++ b/doc/comment_action.md
@@ -0,0 +1,48 @@
+About Action in Issue Comment
+========
+After the issue creation at GitBucket, users can add comments or close it.
+The details are saved at ```ISSUE_COMMENT``` table.
+
+To determine if it was any operation, you see the ```ACTION``` column.
+
+|ACTION|
+|--------|
+|comment|
+|close_comment|
+|reopen_comment|
+|close|
+|reopen|
+|commit|
+|merge|
+|delete_branch|
+|refer|
+
+#####comment
+This value is saved when users have made a normal comment.
+
+#####close_comment, reopen_comment
+These values are saved when users have reopened or closed the issue with comments.
+
+#####close, reopen
+These values are saved when users have reopened or closed the issue.
+At the same time, store the fixed value(i.e. "Close" or "Reopen") to the ```CONTENT``` column.
+Therefore, this comment is not displayed, and not counted as a comment.
+
+#####commit
+This value is saved when users have pushed including the ```#issueId``` to the commit message.
+At the same time, store it to the ```CONTENT``` column with its commit id.
+This comment is displayed. But it can not be edited by all users, and also not counted as a comment.
+
+#####merge
+This value is saved when users have merged the pull request.
+At the same time, store the message to the ```CONTENT``` column.
+This comment is displayed. But it can not be edited by all users, and also not counted as a comment.
+
+#####delete_branch
+This value is saved when users have deleted the branch. Users can delete branch after merging pull request which is requested from the same repository.
+At the same time, store it to the ```CONTENT``` column with the deleted branch name.
+Therefore, this comment is not displayed, and not counted as a comment.
+
+#####refer
+This value is saved when other issue or issue comment contains reference to the issue like ```#issueId```.
+At the same time, store id and title of the referrer issue as ```id:title```.
--- a/doc/directory.md
+++ b/doc/directory.md
@@ -0,0 +1,44 @@
+Directory Structure
+========
+GitBucket persists all data into __HOME/.gitbucket__ in default (In 1.9 or before, HOME/gitbucket is default).
+
+This directory has following structure:
+
+```
+* /HOME/gitbucket
+  * /repositoties
+    * /USER_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)
+  * /data
+    * /USER_NAME
+      * /files
+        * avatar.xxx (image file of user avatar)
+  * /plugins
+    * /PLUGIN_NAME
+      * plugin.js
+  * /tmp
+    * /_upload
+      * /SESSION_ID (removed at session timeout)
+        * current time millis + random 10 alphanumeric chars (temporary file for file uploading)
+    * /USER_NAME
+      * /init-REPO_NAME (used in repository creation and removed after it) ... unused since 1.8
+      * /REPO_NAME.wiki (working directory for wiki repository) ... unused since 1.8
+      * /REPO_NAME
+         * /download (temporary directories are created under this directory)
+```
+
+There are some ways to specify the data directory instead of the default location.
+
+1. Environment variable __GITBUCKET_HOME__
+2. System property __gitbucket.home__ (e.g. ```-Dgitbucket.home=PATH_TO_DATADIR```)
+3. Command line option for embedded Jetty (e.g. ```java -jar gitbucket.war --data=PATH_TO_DATADIR```)
+4. Context parameter __gitbucket.home__ in web.xml like below:
+```xml
+<context-param>
+  <param-name>gitbucket.home</param-name>
+  <param-value>PATH_TO_DATADIR</param-value>
+</context-param>
+```
--- a/doc/how_to_run.md
+++ b/doc/how_to_run.md
@@ -0,0 +1,38 @@
+How to run from the source tree
+========
+
+for Testers
+--------
+
+If you want to test GitBucket, input following command at the root directory of the source tree.
+
+```
+C:\gitbucket> sbt ~container:start
+```
+
+Then access to `http://localhost:8080/` by your browser. The default administrator account is `root` and password is `root`.
+
+for Developers
+--------
+If you want to modify source code and confirm it, you can run GitBucket in auto reloading mode as following:
+
+```
+C:\gitbucket> sbt
+...
+> container:start
+...
+> ~ ;copy-resources;aux-compile
+```
+
+Build war file
+--------
+
+To build war file, run the following command:
+
+```
+C:\gitbucket> sbt package
+```
+
+`gitbucket_2.11-x.x.x.war` is generated into `target/scala-2.11`.
+
+To build executable war file, run Ant 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. Please note the current build.xml works on Windows only. Replace `sbt.bat` with `sbt.sh` in build.xml if you want to run it on Linux.
--- a/doc/notification.md
+++ b/doc/notification.md
@@ -0,0 +1,23 @@
+Notification Email
+========
+
+GitBucket sends email to target users by enabling the notification email by an administrator.
+
+The timing of the notification are as follows:
+
+##### at the issue registration (new issue, new pull request)
+When a record is saved into the ```ISSUE``` table, GitBucket does the notification.
+
+##### at the comment registration
+Among the records in the ```ISSUE_COMMENT``` table, them to be counted as a comment (i.e. the record ```ACTION``` column value is "comment" or "close_comment" or "reopen_comment") are saved, GitBucket does the notification.
+
+##### at the status update (close, reopen, merge)
+When the ```CLOSED``` column value is updated, GitBucket does the notification.
+
+Notified users are as follows:
+
+* individual repository's owner
+* collaborators
+* participants
+
+However, the operation in person is excluded from the target.
--- a/doc/readme.md
+++ b/doc/readme.md
@@ -0,0 +1,10 @@
+Developer's Guide
+========
+ * [How to run from source tree](how_to_run.md)
+ * [Directory Structure](directory.md)
+ * [Mapping and Validation](validation.md)
+ * Authentication in Controller (not yet)
+ * [About Action in Issue Comment](comment_action.md)
+ * [Activity Types](activity.md)
+ * [Notification Email](notification.md)
+ * [Automatic Schema Updating](auto_update.md)
--- a/doc/validation.md
+++ b/doc/validation.md
@@ -0,0 +1,71 @@
+Mapping and Validation
+========
+GitBucket uses [scalatra-forms](https://github.com/takezoe/scalatra-forms) to validate request parameters and map them to the scala object. This is inspired by Play2 form mapping / validation.
+
+At first, define the mapping as following:
+
+```scala
+import jp.sf.amateras.scalatra.forms._
+
+case class RegisterForm(name: String, description: String)
+
+val form = mapping(
+  "name"        -> text(required, maxlength(40)),
+  "description" -> text()
+)(RegisterForm.apply)
+```
+
+The servlet have to mixed in ```jp.sf.amateras.scalatra.forms.ClientSideValidationFormSupport``` to validate request parameters and take mapped object. It validates request parameters before action. If any errors are detected, it throws an exception.
+
+```scala
+class RegisterServlet extends ScalatraServlet with ClientSideValidationFormSupport {
+  post("/register", form) { form: RegisterForm =>
+    ...
+  }
+}
+```
+
+In the view template, you can add client-side validation by adding ```validate="true"``` to your form. Error messages are set to ```span#error-<fieldname>```.
+
+```html
+<form method="POST" action="/register" validate="true">
+  Name: <input type="name" type="text">
+  <span class="error" id="error-name"></span>
+  <br/>
+  Description: <input type="description" type="text">
+  <span class="error" id="error-description"></span>
+  <br/>
+  <input type="submit" value="Register"/>
+</form>
+```
+
+Client-side validation calls ```<form-action>/validate``` to validate form contents. It returns a validation result as JSON. In this case, form action is ```/register```, so ```/register/validate``` is called before submitting a form. ```ClientSideValidationFormSupport``` adds this JSON API automatically.
+
+For Ajax request, you have to use '''ajaxGet''' or '''ajaxPost''' to define action. It almost same as '''get''' or '''post'''. You can implement actions which handle Ajax request as same as normal actions.
+Small difference is they return validation errors as JSON.
+
+```scala
+ajaxPost("/register", form){ form =>
+  ...
+}
+```
+
+You can call these actions using jQuery as below:
+
+```javascript
+$('#register').click(function(e){
+  $.ajax($(this).attr('action'), {
+    type: 'POST',
+    data: {
+      name: $('#name').val(),
+      mail: $('#mail').val()
+    }
+  })
+  .done(function(data){
+    $('#result').text('Registered!');
+  })
+  .fail(function(data, status){
+    displayErrors($.parseJSON(data.responseText));
+  });
+});
+```
--- a/embed-jetty/jetty-continuation-8.1.16.v20140903.jar
+++ b/embed-jetty/jetty-continuation-8.1.16.v20140903.jar
--- a/embed-jetty/jetty-http-8.1.16.v20140903.jar
+++ b/embed-jetty/jetty-http-8.1.16.v20140903.jar
--- a/embed-jetty/jetty-http-8.1.8.v20121106.jar
+++ b/embed-jetty/jetty-http-8.1.8.v20121106.jar
--- a/embed-jetty/jetty-io-8.1.16.v20140903.jar
+++ b/embed-jetty/jetty-io-8.1.16.v20140903.jar
--- a/embed-jetty/jetty-io-8.1.8.v20121106.jar
+++ b/embed-jetty/jetty-io-8.1.8.v20121106.jar
--- a/embed-jetty/jetty-security-8.1.16.v20140903.jar
+++ b/embed-jetty/jetty-security-8.1.16.v20140903.jar
--- a/embed-jetty/jetty-server-8.1.16.v20140903.jar
+++ b/embed-jetty/jetty-server-8.1.16.v20140903.jar
--- a/embed-jetty/jetty-server-8.1.8.v20121106.jar
+++ b/embed-jetty/jetty-server-8.1.8.v20121106.jar
--- a/embed-jetty/jetty-servlet-8.1.16.v20140903.jar
+++ b/embed-jetty/jetty-servlet-8.1.16.v20140903.jar
--- a/embed-jetty/jetty-servlet-8.1.8.v20121106.jar
+++ b/embed-jetty/jetty-servlet-8.1.8.v20121106.jar
--- a/embed-jetty/jetty-util-8.1.16.v20140903.jar
+++ b/embed-jetty/jetty-util-8.1.16.v20140903.jar
--- a/embed-jetty/jetty-util-8.1.8.v20121106.jar
+++ b/embed-jetty/jetty-util-8.1.8.v20121106.jar
--- a/embed-jetty/jetty-webapp-8.1.16.v20140903.jar
+++ b/embed-jetty/jetty-webapp-8.1.16.v20140903.jar
--- a/embed-jetty/jetty-webapp-8.1.8.v20121106.jar
+++ b/embed-jetty/jetty-webapp-8.1.8.v20121106.jar
--- a/embed-jetty/jetty-xml-8.1.16.v20140903.jar
+++ b/embed-jetty/jetty-xml-8.1.16.v20140903.jar
--- a/embed-jetty/jetty-xml-8.1.8.v20121106.jar
+++ b/embed-jetty/jetty-xml-8.1.8.v20121106.jar
--- a/embed-jetty/update.sh
+++ b/embed-jetty/update.sh
@@ -0,0 +1,11 @@
+#!/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
--- a/project/build.properties
+++ b/project/build.properties
@@ -1 +1 @@
-sbt.version=0.13.5
+sbt.version=0.13.8
--- a/project/build.scala
+++ b/project/build.scala
@@ -11,8 +11,8 @@ object MyBuild extends Build {
  val Organization = "gitbucket"
  val Name = "gitbucket"
  val Version = "3.0.0"
-  val ScalaVersion = "2.11.2"
-  val ScalatraVersion = "2.3.0"
+  val ScalaVersion = "2.11.6"
+  val ScalatraVersion = "2.3.1"

  lazy val project = Project (
    "gitbucket",
@@ -42,34 +42,37 @@ object MyBuild extends Build {
    ),
    scalacOptions := Seq("-deprecation", "-language:postfixOps"),
    libraryDependencies ++= Seq(
-      "org.eclipse.jgit" % "org.eclipse.jgit.http.server" % "3.4.1.201406201815-r",
-      "org.eclipse.jgit" % "org.eclipse.jgit.archive" % "3.4.1.201406201815-r",
+      "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.10",
+      "org.json4s" %% "json4s-jackson" % "3.2.11",
      "jp.sf.amateras" %% "scalatra-forms" % "0.1.0",
      "commons-io" % "commons-io" % "2.4",
-      "org.pegdown" % "pegdown" % "1.4.1",
-      "org.apache.commons" % "commons-compress" % "1.5",
-      "org.apache.commons" % "commons-email" % "1.3.1",
-      "org.apache.httpcomponents" % "httpclient" % "4.3",
+      "org.pegdown" % "pegdown" % "1.4.1", // 1.4.2 has incompatible APi changes
+      "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" % "0.11.0",
      "com.typesafe.slick" %% "slick" % "2.1.0",
      "com.novell.ldap" % "jldap" % "2009-10-07",
-      "com.h2database" % "h2" % "1.4.180",
+      "com.h2database" % "h2" % "1.4.186",
 //      "ch.qos.logback" % "logback-classic" % "1.0.13" % "runtime",
-      "org.eclipse.jetty" % "jetty-webapp" % "8.1.8.v20121106" % "container;provided",
+      "org.eclipse.jetty" % "jetty-webapp" % "8.1.16.v20140903" % "container;provided",
      "org.eclipse.jetty.orbit" % "javax.servlet" % "3.0.0.v201112011016" % "container;provided;test" artifacts Artifact("javax.servlet", "jar", "jar"),
-      "junit" % "junit" % "4.11" % "test",
+      "junit" % "junit" % "4.12" % "test",
      "com.mchange" % "c3p0" % "0.9.5",
      "com.typesafe" % "config" % "1.2.1",
-      "com.typesafe.play" %% "twirl-compiler" % "1.0.2"
+      "com.typesafe.play" %% "twirl-compiler" % "1.0.4"
    ),
    play.twirl.sbt.Import.TwirlKeys.templateImports += "gitbucket.core._",
    EclipseKeys.withSource := true,
    javacOptions in compile ++= Seq("-target", "7", "-source", "7"),
    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)
 }
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,11 +1,8 @@
+scalacOptions ++= Seq("-unchecked", "-deprecation", "-feature")
+
 addSbtPlugin("com.typesafe.sbteclipse" % "sbteclipse-plugin" % "2.4.0")
-
-addSbtPlugin("com.github.mpeltonen" % "sbt-idea" % "1.6.0")
-
-addSbtPlugin("org.scalatra.sbt" % "scalatra-sbt" % "0.3.5")
-
-addSbtPlugin("com.typesafe.sbt" % "sbt-twirl" % "1.0.2")
-
-addSbtPlugin("com.timushev.sbt" % "sbt-updates" % "0.1.4")
-
-addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.12.0")
+addSbtPlugin("com.github.mpeltonen"    % "sbt-idea"          % "1.6.0")
+addSbtPlugin("org.scalatra.sbt"        % "scalatra-sbt"      % "0.3.5")
+addSbtPlugin("com.typesafe.sbt"        % "sbt-twirl"         % "1.0.4")
+addSbtPlugin("com.timushev.sbt"        % "sbt-updates"       % "0.1.8")
+addSbtPlugin("com.eed3si9n"            % "sbt-assembly"      % "0.12.0")
--- a/sbt-launch-0.13.5.jar
+++ b/sbt-launch-0.13.5.jar
--- a/sbt-launch-0.13.8.jar
+++ b/sbt-launch-0.13.8.jar
--- a/sbt.bat
+++ b/sbt.bat
@@ -1,2 +1,2 @@
 set SCRIPT_DIR=%~dp0
-java -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.5.jar" %*
+java -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" %*
--- a/sbt.sh
+++ b/sbt.sh
@@ -1,2 +1,2 @@
 #!/bin/sh
-java -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.5.jar "$@"
+java -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 "$@"
--- a/src/main/resources/update/3_1.sql
+++ b/src/main/resources/update/3_1.sql
@@ -0,0 +1,42 @@
+DROP TABLE IF EXISTS ACCESS_TOKEN;
+
+CREATE TABLE ACCESS_TOKEN (
+   ACCESS_TOKEN_ID INT NOT NULL AUTO_INCREMENT,
+   TOKEN_HASH VARCHAR(40) NOT NULL,
+   USER_NAME VARCHAR(100) NOT NULL,
+   NOTE TEXT NOT NULL
+);
+
+ALTER TABLE ACCESS_TOKEN ADD CONSTRAINT IDX_ACCESS_TOKEN_PK PRIMARY KEY (ACCESS_TOKEN_ID);
+ALTER TABLE ACCESS_TOKEN ADD CONSTRAINT IDX_ACCESS_TOKEN_FK0 FOREIGN KEY (USER_NAME) REFERENCES ACCOUNT (USER_NAME)
+  ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE ACCESS_TOKEN ADD CONSTRAINT IDX_ACCESS_TOKEN_TOKEN_HASH UNIQUE(TOKEN_HASH);
+
+
+DROP TABLE IF EXISTS COMMIT_STATUS;
+CREATE TABLE COMMIT_STATUS(
+  COMMIT_STATUS_ID INT AUTO_INCREMENT,
+  USER_NAME VARCHAR(100) NOT NULL,
+  REPOSITORY_NAME VARCHAR(100) NOT NULL,
+  COMMIT_ID VARCHAR(40) NOT NULL,
+  CONTEXT VARCHAR(255) NOT NULL, -- context is too long (maximum is 255 characters)
+  STATE VARCHAR(10) NOT NULL, -- pending, success, error, or failure
+  TARGET_URL VARCHAR(200),
+  DESCRIPTION TEXT,
+  CREATOR VARCHAR(100) NOT NULL,
+  REGISTERED_DATE TIMESTAMP NOT NULL, -- CREATED_AT
+  UPDATED_DATE TIMESTAMP NOT NULL -- UPDATED_AT
+);
+ALTER TABLE COMMIT_STATUS ADD CONSTRAINT IDX_COMMIT_STATUS_PK PRIMARY KEY (COMMIT_STATUS_ID);
+ALTER TABLE COMMIT_STATUS ADD CONSTRAINT IDX_COMMIT_STATUS_1
+  UNIQUE (USER_NAME, REPOSITORY_NAME, COMMIT_ID, CONTEXT);
+ALTER TABLE COMMIT_STATUS ADD CONSTRAINT IDX_COMMIT_STATUS_FK1
+  FOREIGN KEY (USER_NAME, REPOSITORY_NAME)
+  REFERENCES REPOSITORY (USER_NAME, REPOSITORY_NAME)
+  ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE COMMIT_STATUS ADD CONSTRAINT IDX_COMMIT_STATUS_FK2
+  FOREIGN KEY (USER_NAME) REFERENCES ACCOUNT (USER_NAME)
+  ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE COMMIT_STATUS ADD CONSTRAINT IDX_COMMIT_STATUS_FK3
+  FOREIGN KEY (CREATOR) REFERENCES ACCOUNT (USER_NAME)
+  ON DELETE CASCADE ON UPDATE CASCADE;
--- a/src/main/scala/ScalatraBootstrap.scala
+++ b/src/main/scala/ScalatraBootstrap.scala
@@ -1,13 +1,14 @@

 import gitbucket.core.controller._
 import gitbucket.core.plugin.PluginRegistry
-import gitbucket.core.servlet.{TransactionFilter, BasicAuthenticationFilter}
+import gitbucket.core.servlet.{AccessTokenAuthenticationFilter, BasicAuthenticationFilter, TransactionFilter}
 import gitbucket.core.util.Directory

-//import jp.sf.amateras.scalatra.forms.ValidationJavaScriptProvider
-import org.scalatra._
-import javax.servlet._
 import java.util.EnumSet
+import javax.servlet._
+
+import org.scalatra._
+

 class ScalatraBootstrap extends LifeCycle {
  override def init(context: ServletContext) {
@@ -16,7 +17,8 @@ class ScalatraBootstrap extends LifeCycle {
    context.getFilterRegistration("transactionFilter").addMappingForUrlPatterns(EnumSet.allOf(classOf[DispatcherType]), true, "/*")
    context.addFilter("basicAuthenticationFilter", new BasicAuthenticationFilter)
    context.getFilterRegistration("basicAuthenticationFilter").addMappingForUrlPatterns(EnumSet.allOf(classOf[DispatcherType]), true, "/git/*")
-
+    context.addFilter("accessTokenAuthenticationFilter", new AccessTokenAuthenticationFilter)
+    context.getFilterRegistration("accessTokenAuthenticationFilter").addMappingForUrlPatterns(EnumSet.allOf(classOf[DispatcherType]), true, "/api/v3/*")
    // Register controllers
    context.mount(new AnonymousAccessController, "/*")

@@ -45,4 +47,4 @@ class ScalatraBootstrap extends LifeCycle {
      dir.mkdirs()
    }
  }
-}
+}
--- a/src/main/scala/gitbucket/core/api/ApiCombinedCommitStatus.scala
+++ b/src/main/scala/gitbucket/core/api/ApiCombinedCommitStatus.scala
@@ -0,0 +1,25 @@
+package gitbucket.core.api
+
+import gitbucket.core.model.{Account, CommitState, CommitStatus}
+
+
+/**
+ * https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref
+ */
+case class ApiCombinedCommitStatus(
+  state: String,
+  sha: String,
+  total_count: Int,
+  statuses: Iterable[ApiCommitStatus],
+  repository: ApiRepository){
+  // val commit_url = ApiPath(s"/api/v3/repos/${repository.full_name}/${sha}")
+  val url = ApiPath(s"/api/v3/repos/${repository.full_name}/commits/${sha}/status")
+}
+object ApiCombinedCommitStatus {
+  def apply(sha:String, statuses: Iterable[(CommitStatus, Account)], repository:ApiRepository): ApiCombinedCommitStatus = ApiCombinedCommitStatus(
+    state      = CommitState.combine(statuses.map(_._1.state).toSet).name,
+    sha        = sha,
+    total_count= statuses.size,
+    statuses   = statuses.map{ case (s, a)=> ApiCommitStatus(s, ApiUser(a)) },
+    repository = repository)
+}
--- a/src/main/scala/gitbucket/core/api/ApiComment.scala
+++ b/src/main/scala/gitbucket/core/api/ApiComment.scala
@@ -0,0 +1,26 @@
+package gitbucket.core.api
+
+import gitbucket.core.model.IssueComment
+
+import java.util.Date
+
+
+/**
+ * https://developer.github.com/v3/issues/comments/
+ */
+case class ApiComment(
+  id: Int,
+  user: ApiUser,
+  body: String,
+  created_at: Date,
+  updated_at: Date)
+
+object ApiComment{
+  def apply(comment: IssueComment, user: ApiUser): ApiComment =
+    ApiComment(
+      id = comment.commentId,
+      user = user,
+      body = comment.content,
+      created_at = comment.registeredDate,
+      updated_at = comment.updatedDate)
+}
--- a/src/main/scala/gitbucket/core/api/ApiCommit.scala
+++ b/src/main/scala/gitbucket/core/api/ApiCommit.scala
@@ -0,0 +1,48 @@
+package gitbucket.core.api
+
+import gitbucket.core.util.JGitUtil
+import gitbucket.core.util.JGitUtil.CommitInfo
+import gitbucket.core.util.RepositoryName
+
+import org.eclipse.jgit.diff.DiffEntry
+import org.eclipse.jgit.api.Git
+
+import java.util.Date
+
+/**
+ * https://developer.github.com/v3/repos/commits/
+ */
+case class ApiCommit(
+  id: String,
+  message: String,
+  timestamp: Date,
+  added: List[String],
+  removed: List[String],
+  modified: List[String],
+  author: ApiPersonIdent,
+  committer: ApiPersonIdent)(repositoryName:RepositoryName){
+  val url = ApiPath(s"/api/v3/${repositoryName.fullName}/commits/${id}")
+  val html_url = ApiPath(s"/${repositoryName.fullName}/commit/${id}")
+}
+
+object ApiCommit{
+  def apply(git: Git, repositoryName: RepositoryName, commit: CommitInfo): ApiCommit = {
+    val diffs = JGitUtil.getDiffs(git, commit.id, false)
+    ApiCommit(
+      id        = commit.id,
+      message   = commit.fullMessage,
+      timestamp = commit.commitTime,
+      added     = diffs._1.collect {
+        case x if x.changeType == DiffEntry.ChangeType.ADD    => x.newPath
+      },
+      removed   = diffs._1.collect {
+        case x if x.changeType == DiffEntry.ChangeType.DELETE => x.oldPath
+      },
+      modified  = diffs._1.collect {
+        case x if x.changeType != DiffEntry.ChangeType.ADD && x.changeType != DiffEntry.ChangeType.DELETE => x.newPath
+      },
+      author    = ApiPersonIdent.author(commit),
+      committer = ApiPersonIdent.committer(commit)
+    )(repositoryName)
+  }
+}
--- a/src/main/scala/gitbucket/core/api/ApiCommitListItem.scala
+++ b/src/main/scala/gitbucket/core/api/ApiCommitListItem.scala
@@ -0,0 +1,42 @@
+package gitbucket.core.api
+
+import gitbucket.core.api.ApiCommitListItem._
+import gitbucket.core.util.JGitUtil.CommitInfo
+import gitbucket.core.util.RepositoryName
+
+
+/**
+ * https://developer.github.com/v3/repos/commits/
+ */
+case class ApiCommitListItem(
+  sha: String,
+  commit: Commit,
+  author: Option[ApiUser],
+  committer: Option[ApiUser],
+  parents: Seq[Parent])(repositoryName: RepositoryName) {
+  val url = ApiPath(s"/api/v3/repos/${repositoryName.fullName}/commits/${sha}")
+}
+
+object ApiCommitListItem {
+  def apply(commit: CommitInfo, repositoryName: RepositoryName): ApiCommitListItem = ApiCommitListItem(
+    sha    = commit.id,
+    commit = Commit(
+      message   = commit.fullMessage,
+      author    = ApiPersonIdent.author(commit),
+      committer = ApiPersonIdent.committer(commit)
+      )(commit.id, repositoryName),
+    author    = None,
+    committer = None,
+    parents   = commit.parents.map(Parent(_)(repositoryName)))(repositoryName)
+
+  case class Parent(sha: String)(repositoryName: RepositoryName){
+    val url = ApiPath(s"/api/v3/repos/${repositoryName.fullName}/commits/${sha}")
+  }
+
+  case class Commit(
+    message: String,
+    author: ApiPersonIdent,
+    committer: ApiPersonIdent)(sha:String, repositoryName: RepositoryName) {
+    val url = ApiPath(s"/api/v3/repos/${repositoryName.fullName}/git/commits/${sha}")
+  }
+}
--- a/src/main/scala/gitbucket/core/api/ApiCommitStatus.scala
+++ b/src/main/scala/gitbucket/core/api/ApiCommitStatus.scala
@@ -0,0 +1,38 @@
+package gitbucket.core.api
+
+import gitbucket.core.model.CommitStatus
+import gitbucket.core.util.RepositoryName
+
+import java.util.Date
+
+
+/**
+ * https://developer.github.com/v3/repos/statuses/#create-a-status
+ * https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref
+ */
+case class ApiCommitStatus(
+  created_at: Date,
+  updated_at: Date,
+  state: String,
+  target_url: Option[String],
+  description: Option[String],
+  id: Int,
+  context: String,
+  creator: ApiUser
+)(sha: String, repositoryName: RepositoryName) {
+  val url = ApiPath(s"/api/v3/repos/${repositoryName.fullName}/commits/${sha}/statuses")
+}
+
+
+object ApiCommitStatus {
+  def apply(status: CommitStatus, creator:ApiUser): ApiCommitStatus = ApiCommitStatus(
+    created_at = status.registeredDate,
+    updated_at = status.updatedDate,
+    state      = status.state.name,
+    target_url = status.targetUrl,
+    description= status.description,
+    id         = status.commitStatusId,
+    context    = status.context,
+    creator    = creator
+  )(status.commitId, RepositoryName(status))
+}
--- a/src/main/scala/gitbucket/core/api/ApiError.scala
+++ b/src/main/scala/gitbucket/core/api/ApiError.scala
@@ -0,0 +1,5 @@
+package gitbucket.core.api
+
+case class ApiError(
+  message: String,
+  documentation_url: Option[String] = None)
--- a/src/main/scala/gitbucket/core/api/ApiIssue.scala
+++ b/src/main/scala/gitbucket/core/api/ApiIssue.scala
@@ -0,0 +1,31 @@
+package gitbucket.core.api
+
+import gitbucket.core.model.Issue
+
+import java.util.Date
+
+
+/**
+ * https://developer.github.com/v3/issues/
+ */
+case class ApiIssue(
+  number: Int,
+  title: String,
+  user: ApiUser,
+  // labels,
+  state: String,
+  created_at: Date,
+  updated_at: Date,
+  body: String)
+
+object ApiIssue{
+  def apply(issue: Issue, user: ApiUser): ApiIssue =
+    ApiIssue(
+      number = issue.issueId,
+      title  = issue.title,
+      user   = user,
+      state  = if(issue.closed){ "closed" }else{ "open" },
+      body   = issue.content.getOrElse(""),
+      created_at = issue.registeredDate,
+      updated_at = issue.updatedDate)
+}
--- a/src/main/scala/gitbucket/core/api/ApiPath.scala
+++ b/src/main/scala/gitbucket/core/api/ApiPath.scala
@@ -0,0 +1,6 @@
+package gitbucket.core.api
+
+/**
+ * path for api url. if set path '/repos/aa/bb' then, expand 'http://server:post/repos/aa/bb' when converted to json.
+ */
+case class ApiPath(path: String)
--- a/src/main/scala/gitbucket/core/api/ApiPersonIdent.scala
+++ b/src/main/scala/gitbucket/core/api/ApiPersonIdent.scala
@@ -0,0 +1,25 @@
+package gitbucket.core.api
+
+import gitbucket.core.util.JGitUtil.CommitInfo
+
+import java.util.Date
+
+
+case class ApiPersonIdent(
+  name: String,
+  email: String,
+  date: Date)
+
+
+object ApiPersonIdent {
+  def author(commit: CommitInfo): ApiPersonIdent =
+    ApiPersonIdent(
+      name  = commit.authorName,
+      email = commit.authorEmailAddress,
+      date  = commit.authorTime)
+  def committer(commit: CommitInfo): ApiPersonIdent =
+    ApiPersonIdent(
+      name  = commit.committerName,
+      email = commit.committerEmailAddress,
+      date  = commit.commitTime)
+}
--- a/src/main/scala/gitbucket/core/api/ApiPullRequest.scala
+++ b/src/main/scala/gitbucket/core/api/ApiPullRequest.scala
@@ -0,0 +1,59 @@
+package gitbucket.core.api
+
+import gitbucket.core.model.{Issue, PullRequest}
+
+import java.util.Date
+
+
+/**
+ * https://developer.github.com/v3/pulls/
+ */
+case class ApiPullRequest(
+  number: Int,
+  updated_at: Date,
+  created_at: Date,
+  head: ApiPullRequest.Commit,
+  base: ApiPullRequest.Commit,
+  mergeable: Option[Boolean],
+  title: String,
+  body: String,
+  user: ApiUser) {
+  val html_url            = ApiPath(s"${base.repo.html_url.path}/pull/${number}")
+  //val diff_url            = ApiPath(s"${base.repo.html_url.path}/pull/${number}.diff")
+  //val patch_url           = ApiPath(s"${base.repo.html_url.path}/pull/${number}.patch")
+  val url                 = ApiPath(s"${base.repo.url.path}/pulls/${number}")
+  //val issue_url           = ApiPath(s"${base.repo.url.path}/issues/${number}")
+  val commits_url         = ApiPath(s"${base.repo.url.path}/pulls/${number}/commits")
+  val review_comments_url = ApiPath(s"${base.repo.url.path}/pulls/${number}/comments")
+  val review_comment_url  = ApiPath(s"${base.repo.url.path}/pulls/comments/{number}")
+  val comments_url        = ApiPath(s"${base.repo.url.path}/issues/${number}/comments")
+  val statuses_url        = ApiPath(s"${base.repo.url.path}/statuses/${head.sha}")
+}
+
+object ApiPullRequest{
+  def apply(issue: Issue, pullRequest: PullRequest, headRepo: ApiRepository, baseRepo: ApiRepository, user: ApiUser): ApiPullRequest = ApiPullRequest(
+      number     = issue.issueId,
+      updated_at = issue.updatedDate,
+      created_at = issue.registeredDate,
+      head       = Commit(
+                     sha  = pullRequest.commitIdTo,
+                     ref  = pullRequest.requestBranch,
+                     repo = headRepo)(issue.userName),
+      base       = Commit(
+                     sha  = pullRequest.commitIdFrom,
+                     ref  = pullRequest.branch,
+                     repo = baseRepo)(issue.userName),
+      mergeable  = None, // TODO: need check mergeable.
+      title      = issue.title,
+      body       = issue.content.getOrElse(""),
+      user       = user
+    )
+
+  case class Commit(
+    sha: String,
+    ref: String,
+    repo: ApiRepository)(baseOwner:String){
+    val label = if( baseOwner == repo.owner.login ){ ref }else{ s"${repo.owner.login}:${ref}" }
+    val user = repo.owner
+  }
+}
--- a/src/main/scala/gitbucket/core/api/ApiRepository.scala
+++ b/src/main/scala/gitbucket/core/api/ApiRepository.scala
@@ -0,0 +1,48 @@
+package gitbucket.core.api
+
+import gitbucket.core.model.{Account, Repository}
+import gitbucket.core.service.RepositoryService.RepositoryInfo
+
+
+// https://developer.github.com/v3/repos/
+case class ApiRepository(
+  name: String,
+  full_name: String,
+  description: String,
+  watchers: Int,
+  forks: Int,
+  `private`: Boolean,
+  default_branch: String,
+  owner: ApiUser) {
+  val forks_count   = forks
+  val watchers_coun = watchers
+  val url       = ApiPath(s"/api/v3/repos/${full_name}")
+  val http_url  = ApiPath(s"/git/${full_name}.git")
+  val clone_url = ApiPath(s"/git/${full_name}.git")
+  val html_url  = ApiPath(s"/${full_name}")
+}
+
+object ApiRepository{
+  def apply(
+      repository: Repository,
+      owner: ApiUser,
+      forkedCount: Int =0,
+      watchers: Int = 0): ApiRepository =
+    ApiRepository(
+      name        = repository.repositoryName,
+      full_name   = s"${repository.userName}/${repository.repositoryName}",
+      description = repository.description.getOrElse(""),
+      watchers    = 0,
+      forks       = forkedCount,
+      `private`   = repository.isPrivate,
+      default_branch = repository.defaultBranch,
+      owner       = owner
+    )
+
+  def apply(repositoryInfo: RepositoryInfo, owner: ApiUser): ApiRepository =
+    ApiRepository(repositoryInfo.repository, owner, forkedCount=repositoryInfo.forkedCount)
+
+  def apply(repositoryInfo: RepositoryInfo, owner: Account): ApiRepository =
+    this(repositoryInfo.repository, ApiUser(owner))
+
+}
--- a/src/main/scala/gitbucket/core/api/ApiUser.scala
+++ b/src/main/scala/gitbucket/core/api/ApiUser.scala
@@ -0,0 +1,36 @@
+package gitbucket.core.api
+
+import gitbucket.core.model.Account
+
+import java.util.Date
+
+
+case class ApiUser(
+  login: String,
+  email: String,
+  `type`: String,
+  site_admin: Boolean,
+  created_at: Date) {
+  val url                 = ApiPath(s"/api/v3/users/${login}")
+  val html_url            = ApiPath(s"/${login}")
+  // val followers_url       = ApiPath(s"/api/v3/users/${login}/followers")
+  // val following_url       = ApiPath(s"/api/v3/users/${login}/following{/other_user}")
+  // val gists_url           = ApiPath(s"/api/v3/users/${login}/gists{/gist_id}")
+  // val starred_url         = ApiPath(s"/api/v3/users/${login}/starred{/owner}{/repo}")
+  // val subscriptions_url   = ApiPath(s"/api/v3/users/${login}/subscriptions")
+  // val organizations_url   = ApiPath(s"/api/v3/users/${login}/orgs")
+  // val repos_url           = ApiPath(s"/api/v3/users/${login}/repos")
+  // val events_url          = ApiPath(s"/api/v3/users/${login}/events{/privacy}")
+  // val received_events_url = ApiPath(s"/api/v3/users/${login}/received_events")
+}
+
+
+object ApiUser{
+  def apply(user: Account): ApiUser = ApiUser(
+    login      = user.fullName,
+    email      = user.mailAddress,
+    `type`     = if(user.isGroupAccount){ "Organization" }else{ "User" },
+    site_admin = user.isAdmin,
+    created_at = user.registeredDate
+  )
+}
--- a/src/main/scala/gitbucket/core/api/CreateAComment.scala
+++ b/src/main/scala/gitbucket/core/api/CreateAComment.scala
@@ -0,0 +1,7 @@
+package gitbucket.core.api
+
+/**
+ * https://developer.github.com/v3/issues/comments/#create-a-comment
+ * api form
+ */
+case class CreateAComment(body: String)
--- a/src/main/scala/gitbucket/core/api/CreateAStatus.scala
+++ b/src/main/scala/gitbucket/core/api/CreateAStatus.scala
@@ -0,0 +1,26 @@
+package gitbucket.core.api
+
+import gitbucket.core.model.CommitState
+
+/**
+ * https://developer.github.com/v3/repos/statuses/#create-a-status
+ * api form
+ */
+case class CreateAStatus(
+  /* state is Required. The state of the status. Can be one of pending, success, error, or failure. */
+  state: String,
+  /* context is a string label to differentiate this status from the status of other systems. Default: "default" */
+  context: Option[String],
+  /* The target URL to associate with this status. This URL will be linked from the GitHub UI to allow users to easily see the ‘source’ of the Status. */
+  target_url: Option[String],
+  /* description is a short description of the status.*/
+  description: Option[String]
+) {
+  def isValid: Boolean = {
+    CommitState.valueOf(state).isDefined &&
+      // only http
+      target_url.filterNot(f => "\\Ahttps?://".r.findPrefixOf(f).isDefined && f.length<255).isEmpty &&
+      context.filterNot(f => f.length<255).isEmpty &&
+      description.filterNot(f => f.length<1000).isEmpty
+  }
+}
--- a/src/main/scala/gitbucket/core/api/JsonFormat.scala
+++ b/src/main/scala/gitbucket/core/api/JsonFormat.scala
@@ -0,0 +1,44 @@
+package gitbucket.core.api
+
+import org.joda.time.DateTime
+import org.joda.time.DateTimeZone
+import org.joda.time.format._
+import org.json4s._
+import org.json4s.jackson.Serialization
+
+import java.util.Date
+
+import scala.util.Try
+
+
+object JsonFormat {
+  case class Context(baseUrl:String)
+  val parserISO = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss'Z'")
+  val jsonFormats = Serialization.formats(NoTypeHints) + new CustomSerializer[Date](format =>
+    (
+      { case JString(s) => Try(parserISO.parseDateTime(s)).toOption.map(_.toDate)
+        .getOrElse(throw new MappingException("Can't convert " + s + " to Date")) },
+      { case x: Date => JString(parserISO.print(new DateTime(x).withZone(DateTimeZone.UTC))) }
+    )
+  ) + FieldSerializer[ApiUser]() + FieldSerializer[ApiPullRequest]() + FieldSerializer[ApiRepository]() +
+    FieldSerializer[ApiCommitListItem.Parent]() + FieldSerializer[ApiCommitListItem]() + FieldSerializer[ApiCommitListItem.Commit]() +
+    FieldSerializer[ApiCommitStatus]() + FieldSerializer[ApiCommit]() + FieldSerializer[ApiCombinedCommitStatus]() +
+    FieldSerializer[ApiPullRequest.Commit]()
+
+
+  def apiPathSerializer(c: Context) = new CustomSerializer[ApiPath](format =>
+      (
+        {
+          case JString(s) if s.startsWith(c.baseUrl) => ApiPath(s.substring(c.baseUrl.length))
+          case JString(s) => throw new MappingException("Can't convert " + s + " to ApiPath")
+        },
+        {
+          case ApiPath(path) => JString(c.baseUrl+path)
+        }
+      )
+    )
+  /**
+   * convert object to json string
+   */
+  def apply(obj: AnyRef)(implicit c: Context): String = Serialization.write(obj)(jsonFormats + apiPathSerializer(c))
+}
--- a/src/main/scala/gitbucket/core/controller/AccountController.scala
+++ b/src/main/scala/gitbucket/core/controller/AccountController.scala
@@ -1,30 +1,35 @@
 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.util._
-import gitbucket.core.util.Implicits._
-import gitbucket.core.util.Directory._
-import gitbucket.core.util.ControlUtil._
-import gitbucket.core.util.StringUtil._
-import gitbucket.core.ssh.SshUtil
 import gitbucket.core.service._
+import gitbucket.core.ssh.SshUtil
+import gitbucket.core.util.ControlUtil._
+import gitbucket.core.util.Directory._
+import gitbucket.core.util.Implicits._
+import gitbucket.core.util.StringUtil._
+import gitbucket.core.util._
+
 import jp.sf.amateras.scalatra.forms._
 import org.apache.commons.io.FileUtils
-import org.scalatra.i18n.Messages
 import org.eclipse.jgit.api.Git
-import org.eclipse.jgit.lib.{FileMode, Constants}
 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
+

 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 OneselfAuthenticator with UsersAuthenticator with GroupManagerAuthenticator with ReadableUsersAuthenticator
+    with AccessTokenService with WebHookService =>

  case class AccountNewForm(userName: String, password: String, fullName: String, mailAddress: String,
                            url: Option[String], fileId: Option[String])
@@ -34,6 +39,8 @@ trait AccountControllerBase extends AccountManagementControllerBase {

  case class SshKeyForm(title: String, publicKey: String)

+  case class PersonalTokenForm(note: String)
+
  val newForm = mapping(
    "userName"    -> trim(label("User name"    , text(required, maxlength(100), identifier, uniqueUserName))),
    "password"    -> trim(label("Password"     , text(required, maxlength(20)))),
@@ -57,6 +64,10 @@ trait AccountControllerBase extends AccountManagementControllerBase {
    "publicKey" -> trim(label("Key"  , text(required, validPublicKey)))
  )(SshKeyForm.apply)

+  val personalTokenForm = mapping(
+    "note"     -> trim(label("Token", text(required, maxlength(100))))
+  )(PersonalTokenForm.apply)
+
  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)

@@ -145,6 +156,25 @@ 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 =>
@@ -209,6 +239,40 @@ trait AccountControllerBase extends AccountManagementControllerBase {
    redirect(s"/${userName}/_ssh")
  })

+  get("/:userName/_application")(oneselfOnly {
+    val userName = params("userName")
+    getAccountByUserName(userName).map { x =>
+      var tokens = getAccessTokens(x.userName)
+      val generatedToken = flash.get("generatedToken") match {
+        case Some((tokenId:Int, token:String)) => {
+          val gt = tokens.find(_.accessTokenId == tokenId)
+          gt.map{ t =>
+            tokens = tokens.filterNot(_ == t)
+            (t, token)
+          }
+        }
+        case _ => None
+      }
+      html.application(x, tokens, generatedToken)
+    } getOrElse NotFound
+  })
+
+  post("/:userName/_personalToken", personalTokenForm)(oneselfOnly { form =>
+    val userName = params("userName")
+    getAccountByUserName(userName).map { x =>
+      val (tokenId, token) = generateAccessToken(userName, form.note)
+      flash += "generatedToken" -> (tokenId, token)
+    }
+    redirect(s"/${userName}/_application")
+  })
+
+  get("/:userName/_personalToken/delete/:id")(oneselfOnly {
+    val userName = params("userName")
+    val tokenId = params("id").toInt
+    deleteAccessToken(userName, tokenId)
+    redirect(s"/${userName}/_application")
+  })
+
  get("/register"){
    if(context.settings.allowAccountRegistration){
      if(context.loginAccount.isDefined){
--- a/src/main/scala/gitbucket/core/controller/ControllerBase.scala
+++ b/src/main/scala/gitbucket/core/controller/ControllerBase.scala
@@ -1,19 +1,25 @@
 package gitbucket.core.controller

+import gitbucket.core.api.ApiError
+import gitbucket.core.model.Account
 import gitbucket.core.service.{AccountService, SystemSettingsService}
-import gitbucket.core.util._
-import gitbucket.core.util.Implicits._
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Directory._
-import gitbucket.core.model.Account
-import org.scalatra._
-import org.scalatra.json._
-import org.json4s._
+import gitbucket.core.util.Implicits._
+import gitbucket.core.util._
+
 import jp.sf.amateras.scalatra.forms._
 import org.apache.commons.io.FileUtils
+import org.json4s._
+import org.scalatra._
+import org.scalatra.i18n._
+import org.scalatra.json._
+
 import javax.servlet.http.{HttpServletResponse, HttpServletRequest}
 import javax.servlet.{FilterChain, ServletResponse, ServletRequest}
-import org.scalatra.i18n._
+
+import scala.util.Try
+

 /**
 * Provides generic features for controller implementations.
@@ -51,6 +57,9 @@ abstract class ControllerBase extends ScalatraFilter
      // Git repository
      chain.doFilter(request, response)
    } else {
+      if(path.startsWith("/api/v3/")){
+        httpRequest.setAttribute(Keys.Request.APIv3, true)
+      }
      // Scalatra actions
      super.doFilter(request, response, chain)
    }
@@ -74,7 +83,7 @@ abstract class ControllerBase extends ScalatraFilter
    }
  }

-  private def LoginAccount: Option[Account] = session.getAs[Account](Keys.Session.LoginAccount)
+  private def LoginAccount: Option[Account] = request.getAs[Account](Keys.Session.LoginAccount).orElse(session.getAs[Account](Keys.Session.LoginAccount))

  def ajaxGet(path : String)(action : => Any) : Route =
    super.get(path){
@@ -103,6 +112,9 @@ abstract class ControllerBase extends ScalatraFilter
  protected def NotFound() =
    if(request.hasAttribute(Keys.Request.Ajax)){
      org.scalatra.NotFound()
+    } else if(request.hasAttribute(Keys.Request.APIv3)){
+      contentType = formats("json")
+      org.scalatra.NotFound(ApiError("Not Found"))
    } else {
      org.scalatra.NotFound(gitbucket.core.html.error("Not Found"))
    }
@@ -110,6 +122,9 @@ abstract class ControllerBase extends ScalatraFilter
  protected def Unauthorized()(implicit context: Context) =
    if(request.hasAttribute(Keys.Request.Ajax)){
      org.scalatra.Unauthorized()
+    } else if(request.hasAttribute(Keys.Request.APIv3)){
+      contentType = formats("json")
+      org.scalatra.Unauthorized(ApiError("Requires authentication"))
    } else {
      if(context.loginAccount.isDefined){
        org.scalatra.Unauthorized(redirect("/"))
@@ -146,6 +161,15 @@ abstract class ControllerBase extends ScalatraFilter
    response.addHeader("X-Content-Type-Options", "nosniff")
    rawData
  }
+
+  // jenkins send message as 'application/x-www-form-urlencoded' but scalatra already parsed as multi-part-request.
+  def extractFromJsonBody[A](implicit request:HttpServletRequest, mf:Manifest[A]): Option[A] = {
+    (request.contentType.map(_.split(";").head.toLowerCase) match{
+      case Some("application/x-www-form-urlencoded") => multiParams.keys.headOption.map(parse(_))
+      case Some("application/json") => Some(parsedBody)
+      case _ => Some(parse(request.body))
+    }).filterNot(_ == JNothing).flatMap(j => Try(j.extract[A]).toOption)
+  }
 }

 /**
--- a/src/main/scala/gitbucket/core/controller/IndexController.scala
+++ b/src/main/scala/gitbucket/core/controller/IndexController.scala
@@ -1,16 +1,20 @@
 package gitbucket.core.controller

-import gitbucket.core.html
+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.util.{LDAPUtil, Keys, UsersAuthenticator}
 import gitbucket.core.util.Implicits._
+import gitbucket.core.util.{LDAPUtil, Keys, UsersAuthenticator}
+
 import jp.sf.amateras.scalatra.forms._

+
 class IndexController extends IndexControllerBase 
  with RepositoryService with ActivityService with AccountService with UsersAuthenticator

+
 trait IndexControllerBase extends ControllerBase {
  self: RepositoryService with ActivityService with AccountService with UsersAuthenticator =>

@@ -106,4 +110,13 @@ 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."))
+  }
 }
--- a/src/main/scala/gitbucket/core/controller/IssuesController.scala
+++ b/src/main/scala/gitbucket/core/controller/IssuesController.scala
@@ -1,25 +1,27 @@
 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._
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Implicits._
+import gitbucket.core.util._
 import gitbucket.core.view
 import gitbucket.core.view.Markdown
-import jp.sf.amateras.scalatra.forms._

-import IssuesService._
+import jp.sf.amateras.scalatra.forms._
 import org.scalatra.Ok

+
 class IssuesController extends IssuesControllerBase
  with IssuesService with RepositoryService with AccountService with LabelsService with MilestonesService with ActivityService
-  with ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator
+  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
-    with ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator =>
+    with ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator with PullRequestService with WebHookIssueCommentService =>

  case class IssueCreateForm(title: String, content: Option[String],
    assignedUserName: Option[String], milestoneId: Option[Int], labelNames: Option[String])
@@ -76,6 +78,18 @@ 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) => ApiComment(issueComment, ApiUser(user)) })
+    }).getOrElse(NotFound)
+  })
+
  get("/:owner/:repository/issues/new")(readableUsersOnly { repository =>
    defining(repository.owner, repository.name){ case (owner, name) =>
      html.create(
@@ -112,9 +126,12 @@ trait IssuesControllerBase extends ControllerBase {
      // record activity
      recordCreateIssueActivity(owner, name, userName, issueId, form.title)

-      // extract references and create refer comment
      getIssue(owner, name, issueId.toString).foreach { issue =>
+        // extract references and create refer comment
        createReferComment(owner, name, issue, form.title + " " + form.content.getOrElse(""))
+
+        // call web hooks
+        callIssuesWebHook("opened", repository, issue, context.baseUrl, context.loginAccount.get)
      }

      // notifications
@@ -163,6 +180,20 @@ trait IssuesControllerBase extends ControllerBase {
    } 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, ApiUser(context.loginAccount.get)))
+    }) 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}/${
@@ -367,6 +398,22 @@ trait IssuesControllerBase extends ControllerBase {
          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 =>
@@ -419,5 +466,4 @@ trait IssuesControllerBase extends ControllerBase {
          hasWritePermission(owner, repoName, context.loginAccount))
    }
  }
-
 }
--- a/src/main/scala/gitbucket/core/controller/PullRequestsController.scala
+++ b/src/main/scala/gitbucket/core/controller/PullRequestsController.scala
@@ -1,34 +1,39 @@
 package gitbucket.core.controller

+import gitbucket.core.api._
+import gitbucket.core.model.{Account, CommitState, Repository, PullRequest, Issue}
 import gitbucket.core.pulls.html
-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 gitbucket.core.view
-import gitbucket.core.view.helpers
-import org.eclipse.jgit.api.Git
-import jp.sf.amateras.scalatra.forms._
-import org.eclipse.jgit.transport.RefSpec
-import scala.collection.JavaConverters._
-import org.eclipse.jgit.lib.{ObjectId, CommitBuilder, PersonIdent}
-import gitbucket.core.service._
+import gitbucket.core.service.CommitStatusService
+import gitbucket.core.service.MergeService
 import gitbucket.core.service.IssuesService._
 import gitbucket.core.service.PullRequestService._
-import gitbucket.core.service.WebHookService.WebHookPayload
+import gitbucket.core.service._
+import gitbucket.core.util.ControlUtil._
+import gitbucket.core.util.Directory._
+import gitbucket.core.util.Implicits._
+import gitbucket.core.util.JGitUtil._
+import gitbucket.core.util._
+import gitbucket.core.view
+import gitbucket.core.view.helpers
+
+import jp.sf.amateras.scalatra.forms._
+import org.eclipse.jgit.api.Git
+import org.eclipse.jgit.lib.PersonIdent
 import org.slf4j.LoggerFactory
-import org.eclipse.jgit.merge.MergeStrategy
-import org.eclipse.jgit.errors.NoMergeBaseException
+
+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 WebHookService with ReferrerAuthenticator with CollaboratorsAuthenticator
+  with CommitsService with ActivityService with WebHookPullRequestService with ReferrerAuthenticator with CollaboratorsAuthenticator
+  with CommitStatusService with MergeService
+

 trait PullRequestsControllerBase extends ControllerBase {
  self: RepositoryService with AccountService with IssuesService with MilestonesService with LabelsService
-    with CommitsService with ActivityService with PullRequestService with WebHookService with ReferrerAuthenticator with CollaboratorsAuthenticator =>
+    with CommitsService with ActivityService with PullRequestService with WebHookPullRequestService with ReferrerAuthenticator with CollaboratorsAuthenticator
+    with CommitStatusService with MergeService =>

  private val logger = LoggerFactory.getLogger(classOf[PullRequestsControllerBase])

@@ -70,6 +75,24 @@ 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
@@ -78,7 +101,6 @@ trait PullRequestsControllerBase extends ControllerBase {
        using(Git.open(getRepositoryDir(owner, name))){ git =>
          val (commits, diffs) =
            getRequestCompareInfo(owner, name, pullreq.commitIdFrom, owner, name, pullreq.commitIdTo)
-
          html.pullreq(
            issue, pullreq,
            (commits.flatten.map(commit => getCommitComments(owner, name, commit.id, true)).flatten.toList ::: getComments(owner, name, issueId))
@@ -96,14 +118,64 @@ trait PullRequestsControllerBase extends ControllerBase {
    } 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.userName), Set())
+      baseOwner <- users.get(repository.owner)
+      headOwner <- users.get(pullRequest.requestUserName)
+      issueUser <- users.get(issue.userName)
+      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 =>
    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}"){
+          checkConflict(owner, name, pullreq.branch, issueId)
+        }
+        val hasProblem = hasConfrict || (!statuses.isEmpty && CommitState.combine(statuses.map(_.state).toSet) != CommitState.SUCCESS)
        html.mergeguide(
-          checkConflictInPullRequest(owner, name, pullreq.branch, pullreq.requestUserName, name, pullreq.requestBranch, issueId),
+          hasConfrict,
+          hasProblem,
+          issue,
          pullreq,
+          statuses,
+          repository,
          s"${context.baseUrl}/git/${pullreq.requestUserName}/${pullreq.requestRepositoryName}.git")
      }
    } getOrElse NotFound
@@ -140,43 +212,10 @@ trait PullRequestsControllerBase extends ControllerBase {
            // record activity
            recordMergeActivity(owner, name, loginAccount.userName, issueId, form.message)

-            // merge
-            val mergeBaseRefName = s"refs/heads/${pullreq.branch}"
-            val merger = MergeStrategy.RECURSIVE.newMerger(git.getRepository, true)
-            val mergeBaseTip = git.getRepository.resolve(mergeBaseRefName)
-            val mergeTip = git.getRepository.resolve(s"refs/pull/${issueId}/head")
-            val conflicted = try {
-              !merger.merge(mergeBaseTip, mergeTip)
-            } catch {
-              case e: NoMergeBaseException => true
-            }
-            if (conflicted) {
-              throw new RuntimeException("This pull request can't merge automatically.")
-            }
-
-            // creates merge commit
-            val mergeCommit = new CommitBuilder()
-            mergeCommit.setTreeId(merger.getResultTreeId)
-            mergeCommit.setParentIds(Array[ObjectId](mergeBaseTip, mergeTip): _*)
-            val personIdent = new PersonIdent(loginAccount.fullName, loginAccount.mailAddress)
-            mergeCommit.setAuthor(personIdent)
-            mergeCommit.setCommitter(personIdent)
-            mergeCommit.setMessage(s"Merge pull request #${issueId} from ${pullreq.requestUserName}/${pullreq.requestBranch}\n\n" +
-                                   form.message)
-
-            // insertObject and got mergeCommit Object Id
-            val inserter = git.getRepository.newObjectInserter
-            val mergeCommitId = inserter.insert(mergeCommit)
-            inserter.flush()
-            inserter.release()
-
-            // update refs
-            val refUpdate = git.getRepository.updateRef(mergeBaseRefName)
-            refUpdate.setNewObjectId(mergeCommitId)
-            refUpdate.setForceUpdate(false)
-            refUpdate.setRefLogIdent(personIdent)
-            refUpdate.setRefLogMessage("merged", true)
-            refUpdate.update()
+            // merge git repository
+            mergePullRequest(git, pullreq.branch, issueId,
+              s"Merge pull request #${issueId} from ${pullreq.requestUserName}/${pullreq.requestBranch}\n\n" + form.message,
+               new PersonIdent(loginAccount.fullName, loginAccount.mailAddress))

            val (commits, _) = getRequestCompareInfo(owner, name, pullreq.commitIdFrom,
              pullreq.requestUserName, pullreq.requestRepositoryName, pullreq.commitIdTo)
@@ -194,14 +233,7 @@ trait PullRequestsControllerBase extends ControllerBase {
              closeIssuesFromMessage(form.message, loginAccount.userName, owner, name)
            }
            // call web hook
-            getWebHookURLs(owner, name) match {
-              case webHookURLs if(webHookURLs.nonEmpty) =>
-                for(ownerAccount <- getAccountByUserName(owner)){
-                  callWebHook(owner, name, webHookURLs,
-                    WebHookPayload(git, loginAccount, mergeBaseRefName, repository, commits.flatten.toList, ownerAccount))
-                }
-              case _ =>
-            }
+            callPullRequestWebHook("closed", repository, issueId, context.baseUrl, context.loginAccount.get)

            // notifications
            Notifier().toNotify(repository, issueId, "merge"){
@@ -319,10 +351,11 @@ trait PullRequestsControllerBase extends ControllerBase {
      ){ case (oldGit, newGit) =>
        val originBranch = JGitUtil.getDefaultBranch(oldGit, originRepository, tmpOriginBranch).get._2
        val forkedBranch = JGitUtil.getDefaultBranch(newGit, forkedRepository, tmpForkedBranch).get._2
-
-        html.mergecheck(
+        val conflict = LockUtil.lock(s"${originRepository.owner}/${originRepository.name}"){
          checkConflict(originRepository.owner, originRepository.name, originBranch,
-                        forkedRepository.owner, forkedRepository.name, forkedBranch))
+                        forkedRepository.owner, forkedRepository.name, forkedBranch)
+        }
+        html.mergecheck(conflict)
      }
    }) getOrElse NotFound
  })
@@ -352,16 +385,14 @@ trait PullRequestsControllerBase extends ControllerBase {
      commitIdTo            = form.commitIdTo)

    // fetch requested branch
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))){ git =>
-      git.fetch
-        .setRemote(getRepositoryDir(form.requestUserName, form.requestRepositoryName).toURI.toString)
-        .setRefSpecs(new RefSpec(s"refs/heads/${form.requestBranch}:refs/pull/${issueId}/head"))
-        .call
-    }
+    fetchAsPullRequest(repository.owner, repository.name, form.requestUserName, form.requestRepositoryName, form.requestBranch, issueId)

    // record activity
    recordPullRequestActivity(repository.owner, repository.name, loginUserName, issueId, form.title)

+    // call web hook
+    callPullRequestWebHook("opened", repository, issueId, context.baseUrl, context.loginAccount.get)
+
    // notifications
    Notifier().toNotify(repository, issueId, form.content.getOrElse("")){
      Notifier.msgPullRequest(s"${context.baseUrl}/${repository.owner}/${repository.name}/pull/${issueId}")
@@ -370,62 +401,6 @@ trait PullRequestsControllerBase extends ControllerBase {
    redirect(s"/${repository.owner}/${repository.name}/pull/${issueId}")
  })

-  /**
-   * Checks whether conflict will be caused in merging. Returns true if conflict will be caused.
-   */
-  private def checkConflict(userName: String, repositoryName: String, branch: String,
-                            requestUserName: String, requestRepositoryName: String, requestBranch: String): Boolean = {
-    LockUtil.lock(s"${userName}/${repositoryName}"){
-      using(Git.open(getRepositoryDir(requestUserName, requestRepositoryName))) { git =>
-        val remoteRefName = s"refs/heads/${branch}"
-        val tmpRefName = s"refs/merge-check/${userName}/${branch}"
-        val refSpec = new RefSpec(s"${remoteRefName}:${tmpRefName}").setForceUpdate(true)
-        try {
-          // fetch objects from origin repository branch
-          git.fetch
-             .setRemote(getRepositoryDir(userName, repositoryName).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 mergeTip = git.getRepository.resolve(tmpRefName)
-          try {
-            !merger.merge(mergeBaseTip, mergeTip)
-          } catch {
-            case e: NoMergeBaseException =>  true
-          }
-        } finally {
-          val refUpdate = git.getRepository.updateRef(refSpec.getDestination)
-          refUpdate.setForceUpdate(true)
-          refUpdate.delete()
-        }
-      }
-    }
-  }
-
-  /**
-   * Checks whether conflict will be caused in merging within pull request. Returns true if conflict will be caused.
-   */
-  private def checkConflictInPullRequest(userName: String, repositoryName: String, branch: String,
-                                         requestUserName: String, requestRepositoryName: String, requestBranch: String,
-                                         issueId: Int): Boolean = {
-    LockUtil.lock(s"${userName}/${repositoryName}") {
-      using(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
-        // merge
-        val merger = MergeStrategy.RECURSIVE.newMerger(git.getRepository, true)
-        val mergeBaseTip = git.getRepository.resolve(s"refs/heads/${branch}")
-        val mergeTip = git.getRepository.resolve(s"refs/pull/${issueId}/head")
-        try {
-          !merger.merge(mergeBaseTip, mergeTip)
-        } catch {
-          case e: NoMergeBaseException => true
-        }
-      }
-    }
-  }
-
  /**
   * Parses branch identifier and extracts owner and branch name as tuple.
   *
@@ -484,5 +459,4 @@ trait PullRequestsControllerBase extends ControllerBase {
        repository,
        hasWritePermission(owner, repoName, context.loginAccount))
    }
-
 }
--- a/src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala
+++ b/src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala
@@ -3,7 +3,7 @@ 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.WebHookService.WebHookPayload
+import gitbucket.core.service.WebHookService._
 import gitbucket.core.util._
 import gitbucket.core.util.JGitUtil._
 import gitbucket.core.util.ControlUtil._
@@ -15,6 +15,7 @@ import org.scalatra.i18n.Messages
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.lib.Constants

+
 class RepositorySettingsController extends RepositorySettingsControllerBase
  with RepositoryService with AccountService with WebHookService
  with OwnerAuthenticator with UsersAuthenticator
@@ -168,9 +169,9 @@ trait RepositorySettingsControllerBase extends ControllerBase {
        .call.iterator.asScala.map(new CommitInfo(_))

      getAccountByUserName(repository.owner).foreach { ownerAccount =>
-        callWebHook(repository.owner, repository.name,
+        callWebHook("push",
          List(WebHook(repository.owner, repository.name, form.url)),
-          WebHookPayload(git, ownerAccount, "refs/heads/" + repository.repository.defaultBranch, repository, commits.toList, ownerAccount)
+          WebHookPushPayload(git, ownerAccount, "refs/heads/" + repository.repository.defaultBranch, repository, commits.toList, ownerAccount)
        )
      }
      flash += "url"  -> form.url
@@ -273,4 +274,4 @@ trait RepositorySettingsControllerBase extends ControllerBase {
        }
      }
  }
-}
+}
--- a/src/main/scala/gitbucket/core/controller/RepositoryViewerController.scala
+++ b/src/main/scala/gitbucket/core/controller/RepositoryViewerController.scala
@@ -1,38 +1,44 @@
 package gitbucket.core.controller

+import gitbucket.core.api._
 import gitbucket.core.repo.html
 import gitbucket.core.helper
 import gitbucket.core.service._
 import gitbucket.core.util._
 import gitbucket.core.util.JGitUtil._
+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
-import gitbucket.core.service.WebHookService.WebHookPayload
+import gitbucket.core.model.{Account, CommitState}
+import gitbucket.core.service.CommitStatusService
+import gitbucket.core.service.WebHookService._
 import gitbucket.core.view
 import gitbucket.core.view.helpers
-import org.scalatra._

+import jp.sf.amateras.scalatra.forms._
+import org.apache.commons.io.FileUtils
 import org.eclipse.jgit.api.{ArchiveCommand, Git}
 import org.eclipse.jgit.archive.{TgzFormat, ZipFormat}
-import org.eclipse.jgit.lib._
-import org.apache.commons.io.FileUtils
-import org.eclipse.jgit.treewalk._
-import jp.sf.amateras.scalatra.forms._
 import org.eclipse.jgit.dircache.DirCache
+import org.eclipse.jgit.lib._
 import org.eclipse.jgit.revwalk.RevCommit
+import org.eclipse.jgit.treewalk._
+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 ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator with PullRequestService with CommitStatusService
+  with WebHookPullRequestService

 /**
 * The repository viewer.
 */
 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 ReadableUsersAuthenticator with ReferrerAuthenticator with CollaboratorsAuthenticator with PullRequestService with CommitStatusService
+    with WebHookPullRequestService =>

  ArchiveCommand.registerFormat("zip", new ZipFormat)
  ArchiveCommand.registerFormat("tar.gz", new TgzFormat)
@@ -108,6 +114,13 @@ 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.
   */
@@ -139,6 +152,56 @@ 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.
+   */
+  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/#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)
    html.editor(branch, repository, if(path.length == 0) Nil else path.split("/").toList,
@@ -173,9 +236,16 @@ trait RepositoryViewerControllerBase extends ControllerBase {
  })

  post("/:owner/:repository/create", editorForm)(collaboratorsOnly { (form, repository) =>
-    commitFile(repository, form.branch, form.path, Some(form.newFileName), None,
-      StringUtil.convertLineSeparator(form.content, form.lineSeparator), form.charset,
-      form.message.getOrElse(s"Create ${form.newFileName}"))
+    commitFile(
+      repository  = repository,
+      branch      = form.branch,
+      path        = form.path,
+      newFileName = Some(form.newFileName),
+      oldFileName = None,
+      content     = appendNewLine(convertLineSeparator(form.content, form.lineSeparator), form.lineSeparator),
+      charset     = form.charset,
+      message     = form.message.getOrElse(s"Create ${form.newFileName}")
+    )

    redirect(s"/${repository.owner}/${repository.name}/blob/${form.branch}/${
      if(form.path.length == 0) form.newFileName else s"${form.path}/${form.newFileName}"
@@ -183,13 +253,20 @@ trait RepositoryViewerControllerBase extends ControllerBase {
  })

  post("/:owner/:repository/update", editorForm)(collaboratorsOnly { (form, repository) =>
-    commitFile(repository, form.branch, form.path, Some(form.newFileName), form.oldFileName,
-      StringUtil.convertLineSeparator(form.content, form.lineSeparator), form.charset,
-      if(form.oldFileName.exists(_ == form.newFileName)){
+    commitFile(
+      repository  = repository,
+      branch      = form.branch,
+      path        = form.path,
+      newFileName = Some(form.newFileName),
+      oldFileName = form.oldFileName,
+      content     = appendNewLine(convertLineSeparator(form.content, form.lineSeparator), form.lineSeparator),
+      charset     = form.charset,
+      message     = if(form.oldFileName.exists(_ == form.newFileName)){
        form.message.getOrElse(s"Update ${form.newFileName}")
      } else {
        form.message.getOrElse(s"Rename ${form.oldFileName.get} to ${form.newFileName}")
-      })
+      }
+    )

    redirect(s"/${repository.owner}/${repository.name}/blob/${form.branch}/${
      if(form.path.length == 0) form.newFileName else s"${form.path}/${form.newFileName}"
@@ -538,14 +615,12 @@ trait RepositoryViewerControllerBase extends ControllerBase {
        closeIssuesFromMessage(message, loginAccount.userName, repository.owner, repository.name)

        // call web hook
+        callPullRequestWebHookByRequestBranch("synchronize", repository, branch, context.baseUrl, loginAccount)
        val commit = new JGitUtil.CommitInfo(JGitUtil.getRevCommitFromId(git, commitId))
-        getWebHookURLs(repository.owner, repository.name) match {
-          case webHookURLs if(webHookURLs.nonEmpty) =>
-            for(ownerAccount <- getAccountByUserName(repository.owner)){
-              callWebHook(repository.owner, repository.name, webHookURLs,
-                WebHookPayload(git, loginAccount, headName, repository, List(commit), ownerAccount))
-            }
-          case _ =>
+        callWebHookOf(repository.owner, repository.name, "push") {
+          getAccountByUserName(repository.owner).map{ ownerAccount =>
+            WebHookPushPayload(git, loginAccount, headName, repository, List(commit), ownerAccount)
+          }
        }
      }
    }
--- a/src/main/scala/gitbucket/core/controller/UserManagementController.scala
+++ b/src/main/scala/gitbucket/core/controller/UserManagementController.scala
@@ -194,7 +194,7 @@ trait UserManagementControllerBase extends AccountManagementControllerBase {
  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)
+        if(userName == context.loginAccount.get.userName && params.get("removed") == Some("true"))
          Some("You can't disable your account yourself")
        else
          None
--- a/src/main/scala/gitbucket/core/controller/WikiController.scala
+++ b/src/main/scala/gitbucket/core/controller/WikiController.scala
@@ -3,6 +3,7 @@ package gitbucket.core.controller
 import gitbucket.core.wiki.html
 import gitbucket.core.service.{RepositoryService, WikiService, ActivityService, AccountService}
 import gitbucket.core.util._
+import gitbucket.core.util.StringUtil._
 import gitbucket.core.util.ControlUtil._
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util.Directory._
@@ -110,8 +111,16 @@ trait WikiControllerBase extends ControllerBase {
  
  post("/:owner/:repository/wiki/_edit", editForm)(collaboratorsOnly { (form, repository) =>
    defining(context.loginAccount.get){ loginAccount =>
-      saveWikiPage(repository.owner, repository.name, form.currentPageName, form.pageName,
-          form.content, loginAccount, form.message.getOrElse(""), Some(form.id)).map { commitId =>
+      saveWikiPage(
+        repository.owner,
+        repository.name,
+        form.currentPageName,
+        form.pageName,
+        appendNewLine(convertLineSeparator(form.content, "LF"), "LF"),
+        loginAccount,
+        form.message.getOrElse(""),
+        Some(form.id)
+      ).map { commitId =>
        updateLastActivityDate(repository.owner, repository.name)
        recordEditWikiPageActivity(repository.owner, repository.name, loginAccount.userName, form.pageName, commitId)
      }
--- a/src/main/scala/gitbucket/core/model/AccessToken.scala
+++ b/src/main/scala/gitbucket/core/model/AccessToken.scala
@@ -0,0 +1,21 @@
+package gitbucket.core.model
+
+
+trait AccessTokenComponent { self: Profile =>
+  import profile.simple._
+  lazy val AccessTokens = TableQuery[AccessTokens]
+
+  class AccessTokens(tag: Tag) extends Table[AccessToken](tag, "ACCESS_TOKEN") {
+    val accessTokenId = column[Int]("ACCESS_TOKEN_ID", O AutoInc)
+    val userName = column[String]("USER_NAME")
+    val tokenHash = column[String]("TOKEN_HASH")
+    val note = column[String]("NOTE")
+    def * = (accessTokenId, userName, tokenHash, note) <> (AccessToken.tupled, AccessToken.unapply)
+  }
+}
+case class AccessToken(
+  accessTokenId: Int = 0,
+  userName: String,
+  tokenHash: String,
+  note: String
+)
--- a/src/main/scala/gitbucket/core/model/BasicTemplate.scala
+++ b/src/main/scala/gitbucket/core/model/BasicTemplate.scala
@@ -49,6 +49,9 @@ protected[model] trait TemplateComponent { self: Profile =>

    def byCommit(owner: String, repository: String, commitId: String) =
      byRepository(owner, repository) && (this.commitId === commitId)
+
+    def byCommit(owner: Column[String], repository: Column[String], commitId: Column[String]) =
+      byRepository(userName, repositoryName) && (this.commitId === commitId)
  }

 }
--- a/src/main/scala/gitbucket/core/model/CommitStatus.scala
+++ b/src/main/scala/gitbucket/core/model/CommitStatus.scala
@@ -0,0 +1,83 @@
+package gitbucket.core.model
+
+import scala.slick.lifted.MappedTo
+import scala.slick.jdbc._
+
+trait CommitStatusComponent extends TemplateComponent { self: Profile =>
+  import profile.simple._
+  import self._
+
+  implicit val commitStateColumnType = MappedColumnType.base[CommitState, String](b => b.name , i => CommitState(i))
+
+  lazy val CommitStatuses = TableQuery[CommitStatuses]
+  class CommitStatuses(tag: Tag) extends Table[CommitStatus](tag, "COMMIT_STATUS") with CommitTemplate {
+    val commitStatusId = column[Int]("COMMIT_STATUS_ID", O AutoInc)
+    val context = column[String]("CONTEXT")
+    val state = column[CommitState]("STATE")
+    val targetUrl = column[Option[String]]("TARGET_URL")
+    val description = column[Option[String]]("DESCRIPTION")
+    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 byPrimaryKey(id: Int) = commitStatusId === id.bind
+  }
+}
+
+
+case class CommitStatus(
+  commitStatusId: Int = 0,
+  userName: String,
+  repositoryName: String,
+  commitId: String,
+  context: String,
+  state: CommitState,
+  targetUrl: Option[String],
+  description: Option[String],
+  creator: String,
+  registeredDate: java.util.Date,
+  updatedDate: java.util.Date
+)
+
+
+sealed abstract class CommitState(val name: String)
+
+
+object CommitState {
+  object ERROR extends CommitState("error")
+
+  object FAILURE extends CommitState("failure")
+
+  object PENDING extends CommitState("pending")
+
+  object SUCCESS extends CommitState("success")
+
+  val values: Vector[CommitState] = Vector(PENDING, SUCCESS, ERROR, FAILURE)
+
+  private val map: Map[String, CommitState] = values.map(enum => enum.name -> enum).toMap
+
+  def apply(name: String): CommitState = map(name)
+
+  def valueOf(name: String): Option[CommitState] = map.get(name)
+
+  /**
+   * failure if any of the contexts report as error or failure
+   * pending if there are no statuses or a context is pending
+   * success if the latest status for all contexts is success
+   */
+  def combine(statuses: Set[CommitState]): CommitState = {
+    if(statuses.isEmpty){
+      PENDING
+    } else if(statuses.contains(CommitState.ERROR) || statuses.contains(CommitState.FAILURE)) {
+      FAILURE
+    } else if(statuses.contains(CommitState.PENDING)) {
+      PENDING
+    } else {
+      SUCCESS
+    }
+  }
+
+  implicit val getResult: GetResult[CommitState] = GetResult(r => CommitState(r.<<))
+  implicit val getResultOpt: GetResult[Option[CommitState]] = GetResult(r => r.<<?[String].map(CommitState(_)))
+}
+
--- a/src/main/scala/gitbucket/core/model/Profile.scala
+++ b/src/main/scala/gitbucket/core/model/Profile.scala
@@ -1,5 +1,6 @@
 package gitbucket.core.model

+
 trait Profile {
  val profile: slick.driver.JdbcProfile
  import profile.simple._
@@ -31,10 +32,12 @@ trait ProfileProvider { self: Profile =>
 }

 trait CoreProfile extends ProfileProvider with Profile
+  with AccessTokenComponent
  with AccountComponent
  with ActivityComponent
  with CollaboratorComponent
  with CommitCommentComponent
+  with CommitStatusComponent
  with GroupMemberComponent
  with IssueComponent
  with IssueCommentComponent
--- a/src/main/scala/gitbucket/core/plugin/PluginRegistory.scala
+++ b/src/main/scala/gitbucket/core/plugin/PluginRegistory.scala
@@ -54,8 +54,8 @@ class PluginRegistry {

  //def getJavaScripts(): List[(String, String)] = javaScripts.toList

-  def getJavaScript(currentPath: String): Option[String] = {
-    javaScripts.find(x => currentPath.matches(x._1)).map(_._2)
+  def getJavaScript(currentPath: String): List[String] = {
+    javaScripts.filter(x => currentPath.matches(x._1)).toList.map(_._2)
  }

  private case class GlobalAction(
@@ -158,4 +158,4 @@ case class PluginInfo(
  version: String,
  description: String,
  pluginClass: Plugin
-)
+)
--- a/src/main/scala/gitbucket/core/service/AccesTokenService.scala
+++ b/src/main/scala/gitbucket/core/service/AccesTokenService.scala
@@ -0,0 +1,55 @@
+package gitbucket.core.service
+
+import gitbucket.core.model.Profile._
+import profile.simple._
+
+import gitbucket.core.model.{Account, AccessToken}
+import gitbucket.core.util.StringUtil
+
+import scala.util.Random
+
+
+trait AccessTokenService {
+
+  def makeAccessTokenString: String = {
+    val bytes = new Array[Byte](20)
+    Random.nextBytes(bytes)
+    bytes.map("%02x".format(_)).mkString
+  }
+
+  def tokenToHash(token: String): String = StringUtil.sha1(token)
+
+  /**
+   * @retuen (TokenId, Token)
+   */
+  def generateAccessToken(userName: String, note: String)(implicit s: Session): (Int, String) = {
+    var token: String = null
+    var hash: String = null
+    do{
+      token = makeAccessTokenString
+      hash = tokenToHash(token)
+    }while(AccessTokens.filter(_.tokenHash === hash.bind).exists.run)
+    val newToken = AccessToken(
+        userName = userName,
+        note = note,
+        tokenHash = hash)
+    val tokenId = (AccessTokens returning AccessTokens.map(_.accessTokenId)) += newToken
+    (tokenId, token)
+  }
+
+  def getAccountByAccessToken(token: String)(implicit s: Session): Option[Account] =
+    Accounts
+      .innerJoin(AccessTokens)
+      .filter{ case (ac, t) => (ac.userName === t.userName) && (t.tokenHash === tokenToHash(token).bind) && (ac.removed === false.bind) }
+      .map{ case (ac, t) => ac }
+      .firstOption
+
+  def getAccessTokens(userName: String)(implicit s: Session): List[AccessToken] =
+    AccessTokens.filter(_.userName === userName.bind).sortBy(_.accessTokenId.desc).list
+
+  def deleteAccessToken(userName: String, accessTokenId: Int)(implicit s: Session): Unit =
+    AccessTokens filter (t => t.userName === userName.bind && t.accessTokenId === accessTokenId) delete
+
+}
+
+object AccessTokenService extends AccessTokenService
--- a/src/main/scala/gitbucket/core/service/AccountService.scala
+++ b/src/main/scala/gitbucket/core/service/AccountService.scala
@@ -77,6 +77,16 @@ trait AccountService {
  def getAccountByUserName(userName: String, includeRemoved: Boolean = false)(implicit s: Session): Option[Account] =
    Accounts filter(t => (t.userName === userName.bind) && (t.removed === false.bind, !includeRemoved)) firstOption

+  def getAccountsByUserNames(userNames: Set[String], knowns:Set[Account], includeRemoved: Boolean = false)(implicit s: Session): Map[String, Account] = {
+    val map = knowns.map(a => a.userName -> a).toMap
+    val needs = userNames -- map.keySet
+    if(needs.isEmpty){
+      map
+    }else{
+      map ++ Accounts.filter(t => (t.userName inSetBind needs) && (t.removed === false.bind, !includeRemoved)).list.map(a => a.userName -> a).toMap
+    }
+  }
+
  def getAccountByMailAddress(mailAddress: String, includeRemoved: Boolean = false)(implicit s: Session): Option[Account] =
    Accounts filter(t => (t.mailAddress.toLowerCase === mailAddress.toLowerCase.bind) && (t.removed === false.bind, !includeRemoved)) firstOption

--- a/src/main/scala/gitbucket/core/service/CommitStatusService.scala
+++ b/src/main/scala/gitbucket/core/service/CommitStatusService.scala
@@ -0,0 +1,52 @@
+package gitbucket.core.service
+
+import gitbucket.core.model.Profile._
+import profile.simple._
+
+import gitbucket.core.model.{CommitState, CommitStatus, Account}
+import gitbucket.core.util.Implicits._
+import gitbucket.core.util.StringUtil._
+import gitbucket.core.service.RepositoryService.RepositoryInfo
+
+
+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 )
+      .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)
+      }
+
+  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
+
+  def getCommitStatues(userName: String, repositoryName: String, sha: String)(implicit s: Session) :List[CommitStatus] =
+    byCommitStatues(userName, repositoryName, sha).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
+
+  protected def byCommitStatues(userName: String, repositoryName: String, sha: String)(implicit s: Session) = 
+    CommitStatuses.filter(t => t.byCommit(userName, repositoryName, sha) ).sortBy(_.updatedDate desc)
+
+}
--- a/src/main/scala/gitbucket/core/service/IssuesService.scala
+++ b/src/main/scala/gitbucket/core/service/IssuesService.scala
@@ -1,14 +1,16 @@
 package gitbucket.core.service

-import gitbucket.core.model._
-import gitbucket.core.util.StringUtil._
-import gitbucket.core.util.Implicits._
-import scala.slick.jdbc.{StaticQuery => Q}
-import Q.interpolation
-
 import gitbucket.core.model.Profile._
 import profile.simple._

+import gitbucket.core.util.StringUtil._
+import gitbucket.core.util.Implicits._
+import gitbucket.core.model._
+
+import scala.slick.jdbc.{StaticQuery => Q}
+import Q.interpolation
+
+
 trait IssuesService {
  import IssuesService._

@@ -20,6 +22,12 @@ trait IssuesService {
  def getComments(owner: String, repository: String, issueId: Int)(implicit s: Session) =
    IssueComments filter (_.byIssue(owner, repository, issueId)) list

+  def getCommentsForApi(owner: String, repository: String, issueId: Int)(implicit s: Session) =
+    IssueComments.filter(_.byIssue(owner, repository, issueId))
+    .filter(_.action inSetBind Set("comment" , "close_comment", "reopen_comment"))
+    .innerJoin(Accounts).on( (t1, t2) => t1.userName === t2.userName )
+    .list
+
  def getComment(owner: String, repository: String, commentId: String)(implicit s: Session) =
    if (commentId forall (_.isDigit))
      IssueComments filter { t =>
@@ -78,6 +86,47 @@ trait IssuesService {
      .toMap
  }

+  def getCommitStatues(issueList:Seq[(String, String, Int)])(implicit s: Session) :Map[(String, String, Int), CommitStatusInfo] ={
+    if(issueList.isEmpty){
+      Map.empty
+    }else{
+      import scala.slick.jdbc._
+      val issueIdQuery = issueList.map(i => "(PR.USER_NAME=? AND PR.REPOSITORY_NAME=? AND PR.ISSUE_ID=?)").mkString(" OR ")
+      implicit val qset = SetParameter[Seq[(String, String, Int)]] {
+        case (seq, pp) =>
+          for (a <- seq) {
+            pp.setString(a._1)
+            pp.setString(a._2)
+            pp.setInt(a._3)
+          }
+      }
+      import gitbucket.core.model.Profile.commitStateColumnType
+      val query = Q.query[Seq[(String, String, Int)], (String, String, Int, Int, Int, Option[String], Option[CommitState], Option[String], Option[String])](s"""
+        SELECT SUMM.USER_NAME, SUMM.REPOSITORY_NAME, SUMM.ISSUE_ID, CS_ALL, CS_SUCCESS
+             , CSD.CONTEXT, CSD.STATE, CSD.TARGET_URL, CSD.DESCRIPTION
+        FROM (SELECT
+           PR.USER_NAME
+         , PR.REPOSITORY_NAME
+         , PR.ISSUE_ID
+         , COUNT(CS.STATE) AS CS_ALL
+         , SUM(CS.STATE='success') AS CS_SUCCESS
+         , PR.COMMIT_ID_TO AS COMMIT_ID
+          FROM PULL_REQUEST PR
+          JOIN COMMIT_STATUS CS
+            ON PR.USER_NAME=CS.USER_NAME
+           AND PR.REPOSITORY_NAME=CS.REPOSITORY_NAME
+           AND PR.COMMIT_ID_TO=CS.COMMIT_ID
+         WHERE $issueIdQuery
+         GROUP BY PR.USER_NAME, PR.REPOSITORY_NAME, PR.ISSUE_ID) as SUMM
+        LEFT OUTER JOIN COMMIT_STATUS CSD
+          ON SUMM.CS_ALL = 1 AND SUMM.COMMIT_ID = CSD.COMMIT_ID""");
+      query(issueList).list.map{
+        case(userName, repositoryName, issueId, count, successCount, context, state, targetUrl, description) =>
+          (userName, repositoryName, issueId) -> CommitStatusInfo(count, successCount, context, state, targetUrl, description)
+        }.toMap
+    }
+  }
+
  /**
   * Returns the search result against  issues.
   *
@@ -90,8 +139,53 @@ trait IssuesService {
   */
  def searchIssue(condition: IssueSearchCondition, pullRequest: Boolean, offset: Int, limit: Int, repos: (String, String)*)
                 (implicit s: Session): List[IssueInfo] = {
-
    // get issues and comment count and labels
+    val result = searchIssueQueryBase(condition, pullRequest, offset, limit, repos)
+        .leftJoin (IssueLabels) .on { case ((t1, t2), t3) => t1.byIssue(t3.userName, t3.repositoryName, t3.issueId) }
+        .leftJoin (Labels)      .on { case (((t1, t2), t3), t4) => t3.byLabel(t4.userName, t4.repositoryName, t4.labelId) }
+        .leftJoin (Milestones)  .on { case ((((t1, t2), t3), t4), t5) => t1.byMilestone(t5.userName, t5.repositoryName, t5.milestoneId) }
+        .map { case ((((t1, t2), t3), t4), t5) =>
+          (t1, t2.commentCount, t4.labelId.?, t4.labelName.?, t4.color.?, t5.title.?)
+        }
+        .list
+        .splitWith { (c1, c2) =>
+          c1._1.userName       == c2._1.userName &&
+          c1._1.repositoryName == c2._1.repositoryName &&
+          c1._1.issueId        == c2._1.issueId
+        }
+    val status = getCommitStatues(result.map(_.head._1).map(is => (is.userName, is.repositoryName, is.issueId)))
+
+    result.map { issues => issues.head match {
+          case (issue, commentCount, _, _, _, milestone) =>
+            IssueInfo(issue,
+             issues.flatMap { t => t._3.map (
+                 Label(issue.userName, issue.repositoryName, _, t._4.get, t._5.get)
+             )} toList,
+             milestone,
+             commentCount,
+             status.get(issue.userName, issue.repositoryName, issue.issueId))
+        }} toList
+  }
+
+  /** for api
+   * @return (issue, commentCount, pullRequest, headRepository, headOwner)
+   */
+  def searchPullRequestByApi(condition: IssueSearchCondition, offset: Int, limit: Int, repos: (String, String)*)
+                 (implicit s: Session): List[(Issue, Account, Int, PullRequest, Repository, Account)] = {
+    // get issues and comment count and labels
+    searchIssueQueryBase(condition, true, offset, limit, repos)
+      .innerJoin(PullRequests).on { case ((t1, t2), t3) => t3.byPrimaryKey(t1.userName, t1.repositoryName, t1.issueId) }
+      .innerJoin(Repositories).on { case (((t1, t2), t3), t4) => t4.byRepository(t1.userName, t1.repositoryName) }
+      .innerJoin(Accounts).on { case ((((t1, t2), t3), t4), t5) => t5.userName === t1.userName }
+      .innerJoin(Accounts).on { case (((((t1, t2), t3), t4), t5), t6) => t6.userName === t4.userName }
+      .map { case (((((t1, t2), t3), t4), t5), t6) =>
+          (t1, t5, t2.commentCount, t3, t4, t6)
+      }
+      .list
+  }
+
+  private def searchIssueQueryBase(condition: IssueSearchCondition, pullRequest: Boolean, offset: Int, limit: Int, repos: Seq[(String, String)])
+                 (implicit s: Session) =
    searchIssueQuery(repos, condition, pullRequest)
        .innerJoin(IssueOutline).on { (t1, t2) => t1.byIssue(t2.userName, t2.repositoryName, t2.issueId) }
        .sortBy { case (t1, t2) =>
@@ -107,28 +201,7 @@ trait IssuesService {
          }
        }
        .drop(offset).take(limit)
-        .leftJoin (IssueLabels) .on { case ((t1, t2), t3) => t1.byIssue(t3.userName, t3.repositoryName, t3.issueId) }
-        .leftJoin (Labels)      .on { case (((t1, t2), t3), t4) => t3.byLabel(t4.userName, t4.repositoryName, t4.labelId) }
-        .leftJoin (Milestones)  .on { case ((((t1, t2), t3), t4), t5) => t1.byMilestone(t5.userName, t5.repositoryName, t5.milestoneId) }
-        .map { case ((((t1, t2), t3), t4), t5) =>
-          (t1, t2.commentCount, t4.labelId.?, t4.labelName.?, t4.color.?, t5.title.?)
-        }
-        .list
-        .splitWith { (c1, c2) =>
-          c1._1.userName       == c2._1.userName &&
-          c1._1.repositoryName == c2._1.repositoryName &&
-          c1._1.issueId        == c2._1.issueId
-        }
-        .map { issues => issues.head match {
-          case (issue, commentCount, _, _, _, milestone) =>
-            IssueInfo(issue,
-             issues.flatMap { t => t._3.map (
-                 Label(issue.userName, issue.repositoryName, _, t._4.get, t._5.get)
-             )} toList,
-             milestone,
-             commentCount)
-        }} toList
-  }
+

  /**
   * Assembles query for conditional issue searching.
@@ -462,6 +535,8 @@ object IssuesService {
    }
  }

-  case class IssueInfo(issue: Issue, labels: List[Label], milestone: Option[String], commentCount: Int)
+  case class CommitStatusInfo(count: Int, successCount: Int, context: Option[String], state: Option[CommitState], targetUrl: Option[String], description: Option[String])
+
+  case class IssueInfo(issue: Issue, labels: List[Label], milestone: Option[String], commentCount: Int, status:Option[CommitStatusInfo])

 }
--- a/src/main/scala/gitbucket/core/service/MergeService.scala
+++ b/src/main/scala/gitbucket/core/service/MergeService.scala
@@ -0,0 +1,172 @@
+package gitbucket.core.service
+
+import gitbucket.core.model.Account
+import gitbucket.core.util.LockUtil
+import gitbucket.core.util.Directory._
+import gitbucket.core.util.Implicits._
+import gitbucket.core.util.ControlUtil._
+
+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.revwalk.RevWalk
+
+
+trait MergeService {
+  import MergeService._
+  /**
+   * Checks whether conflict will be caused in merging within pull request.
+   * Returns true if conflict will be caused.
+   */
+  def checkConflict(userName: String, repositoryName: String, branch: String, issueId: Int): Boolean = {
+    using(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
+      MergeCacheInfo(git, branch, issueId).checkConflict()
+    }
+  }
+  /**
+   * Checks whether conflict will be caused in merging within pull request.
+   * only cache check.
+   * Returns Some(true) if conflict will be caused.
+   * Returns None if cache has not created yet.
+   */
+  def checkConflictCache(userName: String, repositoryName: String, branch: String, issueId: Int): Option[Boolean] = {
+    using(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
+      MergeCacheInfo(git, branch, issueId).checkConflictCache()
+    }
+  }
+  /** merge pull request */
+  def mergePullRequest(git:Git, branch: String, issueId: Int, message:String, committer:PersonIdent): Unit = {
+    MergeCacheInfo(git, branch, issueId).merge(message, committer)
+  }
+  /** fetch remote branch to my repository refs/pull/{issueId}/head */
+  def fetchAsPullRequest(userName: String, repositoryName: String, requestUserName: String, requestRepositoryName: String, requestBranch:String, issueId:Int){
+    using(Git.open(getRepositoryDir(userName, repositoryName))){ git =>
+      git.fetch
+        .setRemote(getRepositoryDir(requestUserName, requestRepositoryName).toURI.toString)
+        .setRefSpecs(new RefSpec(s"refs/heads/${requestBranch}:refs/pull/${issueId}/head"))
+        .call
+    }
+  }
+  /**
+   * 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}"
+      val refSpec = new RefSpec(s"${remoteRefName}:${tmpRefName}").setForceUpdate(true)
+      try {
+        // fetch objects from origin repository branch
+        git.fetch
+           .setRemote(getRepositoryDir(userName, repositoryName).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 mergeTip = git.getRepository.resolve(tmpRefName)
+        try {
+          !merger.merge(mergeBaseTip, mergeTip)
+        } catch {
+          case e: NoMergeBaseException =>  true
+        }
+      } finally {
+        val refUpdate = git.getRepository.updateRef(refSpec.getDestination)
+        refUpdate.setForceUpdate(true)
+        refUpdate.delete()
+      }
+    }
+  }
+}
+object MergeService{
+  case class MergeCacheInfo(git:Git, branch:String, issueId:Int){
+    val repository = git.getRepository
+    val mergedBranchName = s"refs/pull/${issueId}/merge"
+    val conflictedBranchName = s"refs/pull/${issueId}/conflict"
+    lazy val mergeBaseTip = repository.resolve(s"refs/heads/${branch}")
+    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 )){
+            // merged branch exists
+            Some(false)
+          }else{
+            None
+          }
+      }.orElse(Option(repository.resolve(conflictedBranchName)).flatMap{ conflicted =>
+        if(parseCommit( conflicted ).getParents().toSet == Set( mergeBaseTip, mergeTip )){
+          // conflict branch exists
+          Some(true)
+        }else{
+          None
+        }
+      })
+    }
+    def checkConflict():Boolean ={
+      checkConflictCache.getOrElse(checkConflictForce)
+    }
+    def checkConflictForce():Boolean ={
+      val merger = MergeStrategy.RECURSIVE.newMerger(repository, true)
+      val conflicted = try {
+        !merger.merge(mergeBaseTip, mergeTip)
+      } catch {
+        case e: NoMergeBaseException => true
+      }
+      val mergeTipCommit = using(new RevWalk( repository ))(_.parseCommit( mergeTip ))
+      val committer = mergeTipCommit.getCommitterIdent;
+      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()
+      }
+      if(!conflicted){
+        updateBranch(merger.getResultTreeId, s"Merge ${mergeTip.name} into ${mergeBaseTip.name}", mergedBranchName)
+        git.branchDelete().setForce(true).setBranchNames(conflictedBranchName).call()
+      }else{
+        updateBranch(mergeTipCommit.getTree().getId(), s"can't merge ${mergeTip.name} into ${mergeBaseTip.name}", conflictedBranchName)
+        git.branchDelete().setForce(true).setBranchNames(mergedBranchName).call()
+      }
+      conflicted
+    }
+    // update branch from cache
+    def merge(message:String, committer:PersonIdent) = {
+      if(checkConflict()){
+        throw new RuntimeException("This pull request can't merge automatically.")
+      }
+      val mergeResultCommit = parseCommit( Option(repository.resolve(mergedBranchName)).getOrElse(throw new RuntimeException(s"not found branch ${mergedBranchName}")) )
+      // 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()
+    }
+    // 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 parseCommit(id:ObjectId) = using(new RevWalk( repository ))(_.parseCommit(id))
+  }
+}
--- a/src/main/scala/gitbucket/core/service/PullRequestService.scala
+++ b/src/main/scala/gitbucket/core/service/PullRequestService.scala
@@ -1,10 +1,11 @@
 package gitbucket.core.service

-import gitbucket.core.model.{Issue, PullRequest}
+import gitbucket.core.model.{Account, Issue, PullRequest, WebHook}
 import gitbucket.core.model.Profile._
 import gitbucket.core.util.JGitUtil
 import profile.simple._

+
 trait PullRequestService { self: IssuesService =>
  import PullRequestService._

--- a/src/main/scala/gitbucket/core/service/RepositoryService.scala
+++ b/src/main/scala/gitbucket/core/service/RepositoryService.scala
@@ -55,6 +55,7 @@ trait RepositoryService { self: AccountService =>
        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

        Repositories.filter { t =>
@@ -95,6 +96,7 @@ trait RepositoryService { self: AccountService =>
        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)) :_*)

        // Convert labelId
        val oldLabelMap = labels.map(x => (x.labelId, x.labelName)).toMap
@@ -395,5 +397,4 @@ object RepositoryService {
  }

  case class RepositoryTreeNode(owner: String, name: String, children: List[RepositoryTreeNode])
-
 }
--- a/src/main/scala/gitbucket/core/service/WebHookService.scala
+++ b/src/main/scala/gitbucket/core/service/WebHookService.scala
@@ -1,18 +1,19 @@
 package gitbucket.core.service

-import gitbucket.core.model.{WebHook, Account}
+import gitbucket.core.api._
+import gitbucket.core.model.{WebHook, Account, Issue, PullRequest, IssueComment}
 import gitbucket.core.model.Profile._
-import gitbucket.core.service.RepositoryService.RepositoryInfo
-import gitbucket.core.util.JGitUtil
 import profile.simple._
-import org.slf4j.LoggerFactory
-import RepositoryService.RepositoryInfo
-import org.eclipse.jgit.diff.DiffEntry
-import JGitUtil.CommitInfo
-import org.eclipse.jgit.api.Git
-import org.apache.http.message.BasicNameValuePair
-import org.apache.http.client.entity.UrlEncodedFormEntity
+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
+import org.eclipse.jgit.api.Git
+import org.slf4j.LoggerFactory
+

 trait WebHookService {
  import WebHookService._
@@ -28,26 +29,28 @@ trait WebHookService {
  def deleteWebHookURL(owner: String, repository: String, url :String)(implicit s: Session): Unit =
    WebHooks.filter(_.byPrimaryKey(owner, repository, url)).delete

-  def callWebHook(owner: String, repository: String, webHookURLs: List[WebHook], payload: WebHookPayload): Unit = {
-    import org.json4s._
-    import org.json4s.jackson.Serialization
-    import org.json4s.jackson.Serialization.{read, write}
+  def callWebHookOf(owner: String, repository: String, eventName: String)(makePayload: => Option[WebHookPayload])(implicit s: Session, c: JsonFormat.Context): Unit = {
+    val webHookURLs = getWebHookURLs(owner, repository)
+    if(webHookURLs.nonEmpty){
+      makePayload.map(callWebHook(eventName, webHookURLs, _))
+    }
+  }
+
+  def callWebHook(eventName: String, webHookURLs: List[WebHook], payload: WebHookPayload)(implicit c: JsonFormat.Context): Unit = {
    import org.apache.http.client.methods.HttpPost
    import org.apache.http.impl.client.HttpClientBuilder
    import scala.concurrent._
    import ExecutionContext.Implicits.global

-    logger.debug("start callWebHook")
-    implicit val formats = Serialization.formats(NoTypeHints)
-
    if(webHookURLs.nonEmpty){
-      val json = write(payload)
+      val json = JsonFormat(payload)
      val httpClient = HttpClientBuilder.create.build

      webHookURLs.foreach { webHookUrl =>
        val f = Future {
          logger.debug(s"start web hook invocation for ${webHookUrl}")
          val httpPost = new HttpPost(webHookUrl.url)
+          httpPost.addHeader("X-Github-Event", eventName)

          val params: java.util.List[NameValuePair] = new java.util.ArrayList()
          params.add(new BasicNameValuePair("payload", json))
@@ -67,78 +70,203 @@ trait WebHookService {
    }
    logger.debug("end callWebHook")
  }
+}

+
+trait WebHookPullRequestService extends WebHookService {
+  self: AccountService with RepositoryService with PullRequestService with IssuesService =>
+
+  import WebHookService._
+  // https://developer.github.com/v3/activity/events/types/#issuesevent
+  def callIssuesWebHook(action: String, repository: RepositoryService.RepositoryInfo, issue: Issue, baseUrl: String, sender: Account)(implicit s: Session, context:JsonFormat.Context): Unit = {
+    callWebHookOf(repository.owner, repository.name, "issues"){
+      val users = getAccountsByUserNames(Set(repository.owner, issue.userName), Set(sender))
+      for{
+        repoOwner <- users.get(repository.owner)
+        issueUser <- users.get(issue.userName)
+      } yield {
+        WebHookIssuesPayload(
+          action       = action,
+          number       = issue.issueId,
+          repository   = ApiRepository(repository, ApiUser(repoOwner)),
+          issue        = ApiIssue(issue, ApiUser(issueUser)),
+          sender       = ApiUser(sender))
+      }
+    }
+  }
+
+  def callPullRequestWebHook(action: String, repository: RepositoryService.RepositoryInfo, issueId: Int, baseUrl: String, sender: Account)(implicit s: Session, context:JsonFormat.Context): Unit = {
+    import WebHookService._
+    callWebHookOf(repository.owner, repository.name, "pull_request"){
+      for{
+        (issue, pullRequest) <- getPullRequest(repository.owner, repository.name, issueId)
+        users = getAccountsByUserNames(Set(repository.owner, pullRequest.requestUserName), Set(sender))
+        baseOwner <- users.get(repository.owner)
+        headOwner <- users.get(pullRequest.requestUserName)
+        headRepo  <- getRepository(pullRequest.requestUserName, pullRequest.requestRepositoryName, baseUrl)
+      } yield {
+        WebHookPullRequestPayload(
+          action         = action,
+          issue          = issue,
+          pullRequest    = pullRequest,
+          headRepository = headRepo,
+          headOwner      = headOwner,
+          baseRepository = repository,
+          baseOwner      = baseOwner,
+          sender         = sender)
+      }
+    }
+  }
+
+  def getPullRequestsByRequestForWebhook(userName:String, repositoryName:String, branch:String)
+                                       (implicit s: Session): Map[(Issue, PullRequest, Account, Account), List[WebHook]] =
+    (for{
+      is <- Issues if is.closed    === false.bind
+      pr <- PullRequests if pr.byPrimaryKey(is.userName, is.repositoryName, is.issueId)
+      if pr.requestUserName        === userName.bind
+      if pr.requestRepositoryName  === repositoryName.bind
+      if pr.requestBranch          === branch.bind
+      bu <- Accounts if bu.userName === pr.userName
+      ru <- Accounts if ru.userName === pr.requestUserName
+      wh <- WebHooks if wh.byRepository(is.userName , is.repositoryName)
+    } yield {
+      ((is, pr, bu, ru), wh)
+    }).list.groupBy(_._1).mapValues(_.map(_._2))
+
+  def callPullRequestWebHookByRequestBranch(action: String, requestRepository: RepositoryService.RepositoryInfo, requestBranch: String, baseUrl: String, sender: Account)(implicit s: Session, context:JsonFormat.Context): Unit = {
+    import WebHookService._
+    for{
+      ((issue, pullRequest, baseOwner, headOwner), webHooks) <- getPullRequestsByRequestForWebhook(requestRepository.owner, requestRepository.name, requestBranch)
+      baseRepo <- getRepository(pullRequest.userName, pullRequest.repositoryName, baseUrl)
+    } yield {
+      val payload = WebHookPullRequestPayload(
+        action         = action,
+        issue          = issue,
+        pullRequest    = pullRequest,
+        headRepository = requestRepository,
+        headOwner      = headOwner,
+        baseRepository = baseRepo,
+        baseOwner      = baseOwner,
+        sender         = sender)
+      callWebHook("pull_request", webHooks, payload)
+    }
+  }
+}
+
+trait WebHookIssueCommentService extends WebHookPullRequestService {
+  self: AccountService with RepositoryService with PullRequestService with IssuesService =>
+
+  import WebHookService._
+  def callIssueCommentWebHook(repository: RepositoryService.RepositoryInfo, issue: Issue, issueCommentId: Int, sender: Account)(implicit s: Session, context:JsonFormat.Context): Unit = {
+    callWebHookOf(repository.owner, repository.name, "issue_comment"){
+      for{
+        issueComment <- getComment(repository.owner, repository.name, issueCommentId.toString())
+        users = getAccountsByUserNames(Set(issue.userName, repository.owner, issueComment.userName), Set(sender))
+        issueUser <- users.get(issue.userName)
+        repoOwner <- users.get(repository.owner)
+        commenter <- users.get(issueComment.userName)
+      } yield {
+        WebHookIssueCommentPayload(
+          issue          = issue,
+          issueUser      = issueUser,
+          comment        = issueComment,
+          commentUser    = commenter,
+          repository     = repository,
+          repositoryUser = repoOwner,
+          sender         = sender)
+      }
+    }
+  }
 }

 object WebHookService {
+  trait WebHookPayload

-  case class WebHookPayload(
-    pusher: WebHookUser,
+  // https://developer.github.com/v3/activity/events/types/#pushevent
+  case class WebHookPushPayload(
+    pusher: ApiUser,
    ref: String,
-    commits: List[WebHookCommit],
-    repository: WebHookRepository)
+    commits: List[ApiCommit],
+    repository: ApiRepository
+  ) extends WebHookPayload

-  object WebHookPayload {
+  object WebHookPushPayload {
    def apply(git: Git, pusher: Account, refName: String, repositoryInfo: RepositoryInfo,
-              commits: List[CommitInfo], repositoryOwner: Account): WebHookPayload =
-      WebHookPayload(
-        WebHookUser(pusher.fullName, pusher.mailAddress),
+              commits: List[CommitInfo], repositoryOwner: Account): WebHookPushPayload =
+      WebHookPushPayload(
+        ApiUser(pusher),
        refName,
-        commits.map { commit =>
-          val diffs = JGitUtil.getDiffs(git, commit.id, false)
-          val commitUrl = repositoryInfo.httpUrl.replaceFirst("/git/", "/").stripSuffix(".git") + "/commit/" + commit.id
-
-          WebHookCommit(
-            id        = commit.id,
-            message   = commit.fullMessage,
-            timestamp = commit.commitTime.toString,
-            url       = commitUrl,
-            added     = diffs._1.collect { case x if(x.changeType == DiffEntry.ChangeType.ADD)    => x.newPath },
-            removed   = diffs._1.collect { case x if(x.changeType == DiffEntry.ChangeType.DELETE) => x.oldPath },
-            modified  = diffs._1.collect { case x if(x.changeType != DiffEntry.ChangeType.ADD &&
-              x.changeType != DiffEntry.ChangeType.DELETE) => x.newPath },
-            author    = WebHookUser(
-              name  = commit.committerName,
-              email = commit.committerEmailAddress
-            )
-          )
-        },
-        WebHookRepository(
-          name        = repositoryInfo.name,
-          url         = repositoryInfo.httpUrl,
-          description = repositoryInfo.repository.description.getOrElse(""),
-          watchers    = 0,
-          forks       = repositoryInfo.forkedCount,
-          `private`   = repositoryInfo.repository.isPrivate,
-          owner = WebHookUser(
-            name  = repositoryOwner.userName,
-            email = repositoryOwner.mailAddress
-          )
+        commits.map{ commit => ApiCommit(git, RepositoryName(repositoryInfo), commit) },
+        ApiRepository(
+          repositoryInfo,
+          owner= ApiUser(repositoryOwner)
        )
      )
  }

-  case class WebHookCommit(
-    id: String,
-    message: String,
-    timestamp: String,
-    url: String,
-    added: List[String],
-    removed: List[String],
-    modified: List[String],
-    author: WebHookUser)
+  // https://developer.github.com/v3/activity/events/types/#issuesevent
+  case class WebHookIssuesPayload(
+    action: String,
+    number: Int,
+    repository: ApiRepository,
+    issue: ApiIssue,
+    sender: ApiUser) extends WebHookPayload

-  case class WebHookRepository(
-    name: String,
-    url: String,
-    description: String,
-    watchers: Int,
-    forks: Int,
-    `private`: Boolean,
-    owner: WebHookUser)
+  // https://developer.github.com/v3/activity/events/types/#pullrequestevent
+  case class WebHookPullRequestPayload(
+    action: String,
+    number: Int,
+    repository: ApiRepository,
+    pull_request: ApiPullRequest,
+    sender: ApiUser
+  ) extends WebHookPayload

-  case class WebHookUser(
-    name: String,
-    email: String)
+  object WebHookPullRequestPayload{
+    def apply(action: String,
+        issue: Issue,
+        pullRequest: PullRequest,
+        headRepository: RepositoryInfo,
+        headOwner: Account,
+        baseRepository: RepositoryInfo,
+        baseOwner: Account,
+        sender: Account): WebHookPullRequestPayload = {
+      val headRepoPayload = ApiRepository(headRepository, headOwner)
+      val baseRepoPayload = ApiRepository(baseRepository, baseOwner)
+      val senderPayload = ApiUser(sender)
+      val pr = ApiPullRequest(issue, pullRequest, headRepoPayload, baseRepoPayload, senderPayload)
+      WebHookPullRequestPayload(
+        action       = action,
+        number       = issue.issueId,
+        repository   = pr.base.repo,
+        pull_request = pr,
+        sender       = senderPayload
+      )
+    }
+  }

+  // https://developer.github.com/v3/activity/events/types/#issuecommentevent
+  case class WebHookIssueCommentPayload(
+    action: String,
+    repository: ApiRepository,
+    issue: ApiIssue,
+    comment: ApiComment,
+    sender: ApiUser
+  ) extends WebHookPayload
+
+  object WebHookIssueCommentPayload{
+    def apply(
+        issue: Issue,
+        issueUser: Account,
+        comment: IssueComment,
+        commentUser: Account,
+        repository: RepositoryInfo,
+        repositoryUser: Account,
+        sender: Account): WebHookIssueCommentPayload =
+      WebHookIssueCommentPayload(
+        action       = "created",
+        repository   = ApiRepository(repository, repositoryUser),
+        issue        = ApiIssue(issue, ApiUser(issueUser)),
+        comment      = ApiComment(comment, ApiUser(commentUser)),
+        sender       = ApiUser(sender))
+  }
 }
--- a/src/main/scala/gitbucket/core/service/WikiService.scala
+++ b/src/main/scala/gitbucket/core/service/WikiService.scala
@@ -202,7 +202,7 @@ trait WikiService {
  }

  /**
-   * Save the wiki page.
+   * Save the wiki page and return the commit id.
   */
  def saveWikiPage(owner: String, repository: String, currentPageName: String, newPageName: String,
      content: String, committer: Account, message: String, currentId: Option[String]): Option[String] = {
--- a/src/main/scala/gitbucket/core/servlet/AccessTokenAuthenticationFilter.scala
+++ b/src/main/scala/gitbucket/core/servlet/AccessTokenAuthenticationFilter.scala
@@ -0,0 +1,43 @@
+package gitbucket.core.servlet
+
+import javax.servlet._
+import javax.servlet.http.{HttpServletRequest, HttpServletResponse}
+
+import gitbucket.core.model.Account
+import gitbucket.core.service.AccessTokenService
+import gitbucket.core.util.Keys
+
+import org.scalatra.servlet.ServletApiImplicits._
+import org.scalatra._
+
+
+class AccessTokenAuthenticationFilter extends Filter with AccessTokenService {
+  private val tokenHeaderPrefix = "token "
+
+  override def init(filterConfig: FilterConfig): Unit = {}
+
+  override def destroy(): Unit = {}
+
+  override def doFilter(req: ServletRequest, res: ServletResponse, chain: FilterChain): Unit = {
+    implicit val request = req.asInstanceOf[HttpServletRequest]
+    implicit val session = req.getAttribute(Keys.Request.DBSession).asInstanceOf[slick.jdbc.JdbcBackend#Session]
+    val response = res.asInstanceOf[HttpServletResponse]
+    Option(request.getHeader("Authorization")).map{
+      case auth if auth.startsWith("token ") => AccessTokenService.getAccountByAccessToken(auth.substring(6).trim).toRight(Unit)
+      // TODO Basic Authentication Support
+      case _ => Left(Unit)
+    }.orElse{
+      Option(request.getSession.getAttribute(Keys.Session.LoginAccount).asInstanceOf[Account]).map(Right(_))
+    } match {
+      case Some(Right(account)) => request.setAttribute(Keys.Session.LoginAccount, account); chain.doFilter(req, res)
+      case None => chain.doFilter(req, res)
+      case Some(Left(_)) => {
+        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED)
+        response.setContentType("Content-Type: application/json; charset=utf-8")
+        val w = response.getWriter()
+        w.print("""{ "message": "Bad credentials" }""")
+        w.close()
+      }
+    }
+  }
+}
--- a/src/main/scala/gitbucket/core/servlet/BasicAuthenticationFilter.scala
+++ b/src/main/scala/gitbucket/core/servlet/BasicAuthenticationFilter.scala
@@ -28,7 +28,6 @@ class BasicAuthenticationFilter extends Filter with RepositoryService with Accou
    }

    val isUpdating = request.getRequestURI.endsWith("/git-receive-pack") || "service=git-receive-pack".equals(request.getQueryString)
-
    val settings = loadSystemSettings()

    try {
@@ -44,13 +43,15 @@ class BasicAuthenticationFilter extends Filter with RepositoryService with Accou
                  case auth => decodeAuthHeader(auth).split(":") match {
                    case Array(username, password) => {
                      authenticate(settings, username, password) match {
-                        case Some(account) => {
-                          if(isUpdating && hasWritePermission(repository.owner, repository.name, Some(account))){
+                        case Some(account) if (isUpdating || repository.repository.isPrivate) => {
+                          if(hasWritePermission(repository.owner, repository.name, Some(account))){
                            request.setAttribute(Keys.Request.UserName, account.userName)
+                            chain.doFilter(req, wrappedResponse)
+                          } else {
+                            requireAuth(response)
                          }
-                          chain.doFilter(req, wrappedResponse)
                        }
-                        case None => requireAuth(response)
+                        case _ => requireAuth(response)
                      }
                    }
                    case _ => requireAuth(response)
--- a/src/main/scala/gitbucket/core/servlet/GitRepositoryServlet.scala
+++ b/src/main/scala/gitbucket/core/servlet/GitRepositoryServlet.scala
@@ -1,8 +1,16 @@
 package gitbucket.core.servlet

+import gitbucket.core.api
 import gitbucket.core.model.Session
+import gitbucket.core.service.IssuesService.IssueSearchCondition
+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
 import org.eclipse.jgit.http.server.GitServlet
 import org.eclipse.jgit.lib._
 import org.eclipse.jgit.transport._
@@ -12,13 +20,7 @@ import org.slf4j.LoggerFactory
 import javax.servlet.ServletConfig
 import javax.servlet.ServletContext
 import javax.servlet.http.{HttpServletResponse, HttpServletRequest}
-import gitbucket.core.util.StringUtil
-import gitbucket.core.util.ControlUtil._
-import gitbucket.core.util.Implicits._
-import WebHookService._
-import org.eclipse.jgit.api.Git
-import JGitUtil.CommitInfo
-import IssuesService.IssueSearchCondition
+

 /**
 * Provides Git repository via HTTP.
@@ -98,7 +100,8 @@ 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 RepositoryService with AccountService with IssuesService with ActivityService with PullRequestService with WebHookService
+  with WebHookPullRequestService {
  
  private val logger = LoggerFactory.getLogger(classOf[CommitLogHook])
  private var existIds: Seq[String] = Nil
@@ -122,6 +125,7 @@ class CommitLogHook(owner: String, repository: String, pusher: String, baseUrl:
        val pushedIds = scala.collection.mutable.Set[String]()
        commands.asScala.foreach { command =>
          logger.debug(s"commandType: ${command.getType}, refName: ${command.getRefName}")
+          implicit val apiContext = api.JsonFormat.Context(baseUrl)
          val refName = command.getRefName.split("/")
          val branchName = refName.drop(2).mkString("/")
          val commits = if (refName(1) == "tags") {
@@ -138,8 +142,10 @@ 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
+
          // Extract new commit and apply issue comment
-          val defaultBranch = getRepository(owner, repository, baseUrl).get.repository.defaultBranch
+          val defaultBranch = repositoryInfo.repository.defaultBranch
          val newCommits = commits.flatMap { commit =>
            if (!existIds.contains(commit.id) && !pushedIds.contains(commit.id)) {
              if (issueCount > 0) {
@@ -176,20 +182,19 @@ class CommitLogHook(owner: String, repository: String, pusher: String, baseUrl:
                   ReceiveCommand.Type.UPDATE |
                   ReceiveCommand.Type.UPDATE_NONFASTFORWARD =>
                updatePullRequests(owner, repository, branchName)
+                getAccountByUserName(pusher).map{ pusherAccount =>
+                  callPullRequestWebHookByRequestBranch("synchronize", repositoryInfo, branchName, baseUrl, pusherAccount)
+                }
              case _ =>
            }
          }

          // call web hook
-          getWebHookURLs(owner, repository) match {
-            case webHookURLs if(webHookURLs.nonEmpty) =>
-              for(pusherAccount <- getAccountByUserName(pusher);
-                  ownerAccount   <- getAccountByUserName(owner);
-                  repositoryInfo <- getRepository(owner, repository, baseUrl)){
-                callWebHook(owner, repository, webHookURLs,
-                  WebHookPayload(git, pusherAccount, command.getRefName, repositoryInfo, newCommits, ownerAccount))
-              }
-            case _ =>
+          callWebHookOf(owner, repository, "push"){
+            for(pusherAccount <- getAccountByUserName(pusher);
+              ownerAccount   <- getAccountByUserName(owner)) yield {
+              WebHookPushPayload(git, pusherAccount, command.getRefName, repositoryInfo, newCommits, ownerAccount)
+            }
          }
        }
      }
--- a/src/main/scala/gitbucket/core/servlet/InitializeListener.scala
+++ b/src/main/scala/gitbucket/core/servlet/InitializeListener.scala
@@ -21,6 +21,7 @@ object AutoUpdate {
   * The history of versions. A head of this sequence is the current BitBucket version.
   */
  val versions = Seq(
+    new Version(3, 1),
    new Version(3, 0),
    new Version(2, 8),
    new Version(2, 7) {
--- a/src/main/scala/gitbucket/core/servlet/TransactionFilter.scala
+++ b/src/main/scala/gitbucket/core/servlet/TransactionFilter.scala
@@ -20,7 +20,7 @@ class TransactionFilter extends Filter {
  def destroy(): Unit = {}

  def doFilter(req: ServletRequest, res: ServletResponse, chain: FilterChain): Unit = {
-    if(req.asInstanceOf[HttpServletRequest].getRequestURI().startsWith("/assets/")){
+    if(req.asInstanceOf[HttpServletRequest].getServletPath().startsWith("/assets/")){
      // assets don't need transaction
      chain.doFilter(req, res)
    } else {
--- a/src/main/scala/gitbucket/core/util/Implicits.scala
+++ b/src/main/scala/gitbucket/core/util/Implicits.scala
@@ -1,11 +1,16 @@
 package gitbucket.core.util

+import gitbucket.core.api.JsonFormat
+import gitbucket.core.controller.Context
 import gitbucket.core.servlet.Database

+import javax.servlet.http.{HttpSession, HttpServletRequest}
+
 import scala.util.matching.Regex
 import scala.util.control.Exception._
+
 import slick.jdbc.JdbcBackend
-import javax.servlet.http.{HttpSession, HttpServletRequest}
+

 /**
 * Provides some usable implicit conversions.
@@ -15,6 +20,8 @@ object Implicits {
  // Convert to slick session.
  implicit def request2Session(implicit request: HttpServletRequest): JdbcBackend#Session = Database.getSession(request)

+  implicit def context2ApiJsonFormatContext(implicit context: Context): JsonFormat.Context = JsonFormat.Context(context.baseUrl)
+
  implicit class RichSeq[A](seq: Seq[A]) {

    def splitWith(condition: (A, A) => Boolean): Seq[Seq[A]] = split(seq)(condition)
@@ -56,7 +63,10 @@ object Implicits {

  implicit class RichRequest(request: HttpServletRequest){

-    def paths: Array[String] = request.getRequestURI.substring(request.getContextPath.length + 1).split("/")
+    def paths: Array[String] = (request.getRequestURI match{
+      case path if path.startsWith("/api/v3/repos/") => path.substring(13/* "/api/v3/repos".length */)
+      case path => path
+    }).substring(request.getContextPath.length + 1).split("/")

    def hasQueryString: Boolean = request.getQueryString != null

--- a/src/main/scala/gitbucket/core/util/JGitUtil.scala
+++ b/src/main/scala/gitbucket/core/util/JGitUtil.scala
@@ -179,7 +179,7 @@ object JGitUtil {
          git.tagList.call.asScala.map { ref =>
            val revCommit = getRevCommitFromId(git, ref.getObjectId)
            TagInfo(ref.getName.stripPrefix("refs/tags/"), revCommit.getCommitterIdent.getWhen, revCommit.getName)
-          }.toList
+          }.sortBy(_.time).toList
        )
      } catch {
        // not initialized
@@ -445,6 +445,7 @@ object JGitUtil {
    newTreeIter.reset(reader, git.getRepository.resolve(to + "^{tree}"))

    import scala.collection.JavaConverters._
+    git.getRepository.getConfig.setString("diff", null, "renames", "copies")
    git.diff.setNewTree(newTreeIter).setOldTree(oldTreeIter).call.asScala.map { diff =>
      if(!fetchContent || FileUtil.isImage(diff.getOldPath) || FileUtil.isImage(diff.getNewPath)){
        DiffInfo(diff.getChangeType, diff.getOldPath, diff.getNewPath, None, None)
@@ -781,4 +782,17 @@ object JGitUtil {
      blameMap.values.map{b => b.copy(lines=limeMap(b.id))}
    }.getOrElse(Seq.empty)
  }
+
+  /**
+   * Returns sha1
+   * @param owner repository owner
+   * @param name  repository name
+   * @param revstr  A git object references expression
+   * @return sha1
+   */
+  def getShaByRef(owner:String, name:String,revstr: String): Option[String] = {
+    using(Git.open(getRepositoryDir(owner, name))){ git =>
+      Option(git.getRepository.resolve(revstr)).map(ObjectId.toString(_))
+    }
+  }
 }
--- a/src/main/scala/gitbucket/core/util/Keys.scala
+++ b/src/main/scala/gitbucket/core/util/Keys.scala
@@ -71,6 +71,11 @@ object Keys {
     */
    val Ajax = "AJAX"

+    /**
+     * Request key for the /api/v3 request flag.
+     */
+    val APIv3 = "APIv3"
+
    /**
     * Request key for the username which is used during Git repository access.
     */
--- a/src/main/scala/gitbucket/core/util/RepoitoryName.scala
+++ b/src/main/scala/gitbucket/core/util/RepoitoryName.scala
@@ -0,0 +1,18 @@
+package gitbucket.core.util
+
+case class RepositoryName(owner:String, name:String){
+  val fullName = s"${owner}/${name}"
+}
+
+object RepositoryName{
+  def apply(fullName: String): RepositoryName = {
+    fullName.split("/").toList match {
+      case owner :: name :: Nil => RepositoryName(owner, name)
+      case _ => throw new IllegalArgumentException(s"${fullName} is not repositoryName (only 'owner/name')")
+    }
+  }
+  def apply(repository: gitbucket.core.model.Repository): RepositoryName = RepositoryName(repository.userName, repository.repositoryName)
+  def apply(repository: gitbucket.core.util.JGitUtil.RepositoryInfo): RepositoryName = RepositoryName(repository.owner, repository.name)
+  def apply(repository: gitbucket.core.service.RepositoryService.RepositoryInfo): RepositoryName = RepositoryName(repository.owner, repository.name)
+  def apply(repository: gitbucket.core.model.CommitStatus): RepositoryName = RepositoryName(repository.userName, repository.repositoryName)
+}
--- a/src/main/scala/gitbucket/core/util/StringUtil.scala
+++ b/src/main/scala/gitbucket/core/util/StringUtil.scala
@@ -62,6 +62,21 @@ object StringUtil {
    }
  }

+  /**
+   * Appends LF if the given string does not end with LF.
+   *
+   * @param content the content
+   * @param lineSeparator "LF" or "CRLF"
+   * @return the converted content
+   */
+  def appendNewLine(content: String, lineSeparator: String): String = {
+    if(lineSeparator == "CRLF") {
+      if (content.endsWith("\r\n")) content else content + "\r\n"
+    } else {
+      if (content.endsWith("\n")) content else content + "\n"
+    }
+  }
+
  /**
   * Extract issue id like ```#issueId``` from the given message.
   *
--- a/src/main/scala/gitbucket/core/view/helpers.scala
+++ b/src/main/scala/gitbucket/core/view/helpers.scala
@@ -4,10 +4,15 @@ import java.text.SimpleDateFormat
 import java.util.{Date, Locale, TimeZone}

 import gitbucket.core.controller.Context
+import gitbucket.core.model.CommitState
 import gitbucket.core.service.{RepositoryService, RequestCache}
 import gitbucket.core.util.{JGitUtil, StringUtil}
+
 import play.twirl.api.Html

+
+
+
 /**
 * Provides helper methods for Twirl templates.
 */
@@ -263,4 +268,17 @@ object helpers extends AvatarImageProvider with LinkConverter with RequestCache
    def mkHtml(separator: scala.xml.Elem) = Html(seq.mkString(separator.toString))
  }

+  def commitStateIcon(state: CommitState) = Html(state match {
+    case CommitState.PENDING => "●"
+    case CommitState.SUCCESS => "&#x2714;"
+    case CommitState.ERROR   => "×"
+    case CommitState.FAILURE => "×"
+  })
+
+  def commitStateText(state: CommitState, commitId:String) = state match {
+    case CommitState.PENDING => "Waiting to hear about "+commitId.substring(0,8)
+    case CommitState.SUCCESS => "All is well"
+    case CommitState.ERROR   => "Failed"
+    case CommitState.FAILURE => "Failed"
+  }
 }
--- a/src/main/twirl/gitbucket/core/account/application.scala.html
+++ b/src/main/twirl/gitbucket/core/account/application.scala.html
@@ -0,0 +1,57 @@
+@(account: gitbucket.core.model.Account,
+  personalTokens: List[gitbucket.core.model.AccessToken],
+  gneratedToken: Option[(gitbucket.core.model.AccessToken, String)])(implicit context: gitbucket.core.controller.Context)
+@import context._
+@import gitbucket.core.view.helpers._
+@html.main("Applications"){
+<div class="container">
+  <div class="row-fluid">
+    <div class="span3">
+      @menu("application", settings.ssh)
+    </div>
+    <div class="span9">
+      <div class="box">
+        <div class="box-header">Personal access tokens</div>
+        <div class="box-content">
+          @if(personalTokens.isEmpty && gneratedToken.isEmpty){
+            No tokens.
+          }else{
+            Tokens you have generated that can be used to access the GitBucket API.<hr>
+          }
+          @gneratedToken.map{ case (token, tokenString) =>
+            <div class="alert alert-info">
+              Make sure to copy your new personal access token now. You won't be able to see it again!
+            </div>
+            @helper.html.copy("generated-token-copy", tokenString){
+              <input type="text" value="@tokenString" style="width:21em" readonly>
+            }
+            <a href="@path/@account.userName/_personalToken/delete/@token.accessTokenId" class="btn btn-mini btn-danger pull-right">Delete</a>
+            <hr>
+          }
+          @personalTokens.zipWithIndex.map { case (token, i) =>
+            @if(i != 0){
+              <hr>
+            }
+            <strong>@token.note</strong>
+            <a href="@path/@account.userName/_personalToken/delete/@token.accessTokenId" class="btn btn-mini btn-danger pull-right">Delete</a>
+          }
+        </div>
+      </div>
+      <form method="POST" action="@path/@account.userName/_personalToken" validate="true">
+        <div class="box">
+          <div class="box-header">Generate new token</div>
+          <div class="box-content">
+            <fieldset>
+              <label for="note" class="strong">Token description</label>
+              <div><span id="error-note" class="error"></span></div>
+              <input type="text" name="note" id="note" style="width: 400px;"/>
+              <p class="muted">What's this token for?</p>
+            </fieldset>
+            <input type="submit" class="btn btn-success" value="Generate token"/>
+          </div>
+        </div>
+      </form>
+    </div>
+  </div>
+</div>
+}
--- a/src/main/twirl/gitbucket/core/account/edit.scala.html
+++ b/src/main/twirl/gitbucket/core/account/edit.scala.html
@@ -22,7 +22,7 @@
                  <label for="password" class="strong">
                    Password (input to change password):
                  </label>
-                  <input type="password" name="password" id="password" value=""/>
+                  <input type="password" name="password" id="password" value="" autocomplete="off"/>
                  <span id="error-password" class="error"></span>
                </fieldset>
              }
--- a/src/main/twirl/gitbucket/core/account/menu.scala.html
+++ b/src/main/twirl/gitbucket/core/account/menu.scala.html
@@ -10,5 +10,8 @@
      <a href="@path/@loginAccount.get.userName/_ssh">SSH Keys</a>
    </li>
    }
+    <li@if(active=="application"){ class="active"}>
+      <a href="@path/@loginAccount.get.userName/_application">Applications</a>
+    </li>
  </ul>
 </div>
--- a/src/main/twirl/gitbucket/core/dashboard/issueslist.scala.html
+++ b/src/main/twirl/gitbucket/core/dashboard/issueslist.scala.html
@@ -15,7 +15,7 @@
      @dashboard.html.header(openCount, closedCount, condition, groups)
    </th>
  </tr>
-  @issues.map { case IssueInfo(issue, labels, milestone, commentCount) =>
+  @issues.map { case IssueInfo(issue, labels, milestone, commentCount, commitStatus) =>
  <tr>
    <td style="padding-top: 15px; padding-bottom: 15px;">
      @if(issue.isPullRequest){
@@ -29,6 +29,7 @@
      } else {
        <a href="@path/@issue.userName/@issue.repositoryName/issues/@issue.issueId" class="issue-title">@issue.title</a>
      }
+      @gitbucket.core.issues.html.commitstatus(issue, commitStatus)
      @labels.map { label =>
        <span class="label-color small" style="background-color: #@label.color; color: #@label.fontColor; padding-left: 4px; padding-right: 4px">@label.labelName</span>
      }
--- a/src/main/twirl/gitbucket/core/helper/commitcomment.scala.html
+++ b/src/main/twirl/gitbucket/core/helper/commitcomment.scala.html
@@ -29,7 +29,7 @@
        }
      </span>
    </div>
-    <div class="box-content commit-commentContent-@comment.commentId">
+    <div class="box-content commit-commentContent-@comment.commentId markdown-body">
      @markdown(comment.content, repository, false, true, true, hasWritePermission)
    </div>
  </div>
--- a/src/main/twirl/gitbucket/core/helper/diff.scala.html
+++ b/src/main/twirl/gitbucket/core/helper/diff.scala.html
@@ -10,7 +10,7 @@
@import gitbucket.core.view.helpers._
@import org.eclipse.jgit.diff.DiffEntry.ChangeType
@if(showIndex){
-  <div>
+  <div style="overflow: hidden;">
    <div class="pull-right" style="margin-bottom: 10px;">
      <div class="btn-group" data-toggle="buttons-radio">
        <input type="button" id="btn-unified" class="btn btn-default btn-small active" value="Unified">
@@ -22,6 +22,7 @@
  <ul id="commit-file-list" style="display: none;">
  @diffs.zipWithIndex.map { case (diff, i) =>
    <li@if(i > 0){ class="border"}>
+      <span class="pull-right diffstat" data-diff-id="@i"></span>
      <a href="#diff-@i">
        @if(diff.changeType == ChangeType.COPY || diff.changeType == ChangeType.RENAME){
          <img src="@assets/common/images/diff_move.png"/> @diff.oldPath -> @diff.newPath
@@ -42,48 +43,57 @@
 }
@diffs.zipWithIndex.map { case (diff, i) =>
  <a name="diff-@i"></a>
-  <table class="table table-bordered" commitId="@newCommitId" fileName="@diff.newPath">
+  <table class="table table-bordered diff-outside" commitId="@newCommitId" fileName="@diff.newPath" data-diff-id="@i">
    <tr>
      <th style="font-weight: normal; line-height: 27px;" class="box-header">
        @if(diff.changeType == ChangeType.COPY || diff.changeType == ChangeType.RENAME){
-          <img src="@assets/common/images/diff_move.png"/> @diff.oldPath -> @diff.newPath
          @if(newCommitId.isDefined){
            <div class="pull-right align-right">
+              <label class="checkbox" style="display: inline-block;"><input type="checkbox" class="ignore-whitespace" value="1"/>Ignore Space</label>
              <label class="checkbox" style="display: inline-block;"><input type="checkbox" class="toggle-notes" checked><span>Show notes</span></label>
-              <a href="@url(repository)/blob/@newCommitId.get/@diff.newPath" class="btn btn-small">View file @@ @newCommitId.get.substring(0, 10)</a>
+              <a href="@url(repository)/blob/@newCommitId.get/@diff.newPath" class="btn btn-small" title="View the whole file at version @newCommitId.get.substring(0, 10)" data-toggle="tooltip">View</a>
            </div>
          }
+          <span class="diffstat">
+            <img src="@assets/common/images/diff_move.png"/>
+          </span> @diff.oldPath -> @diff.newPath
        }
        @if(diff.changeType == ChangeType.ADD || diff.changeType == ChangeType.MODIFY){
+          @if(newCommitId.isDefined){
+            <div class="pull-right align-right">
+              <label class="checkbox" style="display: inline-block;"><input type="checkbox" class="ignore-whitespace" value="1"/>Ignore Space</label>
+              <label class="checkbox" style="display: inline-block;"><input type="checkbox" class="toggle-notes" checked><span>Show notes</span></label>
+              <a href="@url(repository)/blob/@newCommitId.get/@diff.newPath" class="btn btn-small" title="View the whole file at version @newCommitId.get.substring(0, 10)" data-toggle="tooltip">View</a>
+            </div>
+          }
+          <span class="diffstat">
          @if(diff.changeType == ChangeType.ADD){
            <img src="@assets/common/images/diff_add.png"/>
          }else{
            <img src="@assets/common/images/diff_edit.png"/>
-          } @diff.newPath
-          @if(newCommitId.isDefined){
-            <div class="pull-right align-right">
-              <label class="checkbox" style="display: inline-block;"><input type="checkbox" class="toggle-notes" checked><span>Show notes</span></label>
-              <a href="@url(repository)/blob/@newCommitId.get/@diff.newPath" class="btn btn-small">View file @@ @newCommitId.get.substring(0, 10)</a>
-            </div>
          }
+          </span>
+          @diff.newPath
        }
        @if(diff.changeType == ChangeType.DELETE){
-          <img src="@assets/common/images/diff_delete.png"/> @diff.oldPath
          @if(oldCommitId.isDefined){
            <div class="pull-right align-right">
              <label class="checkbox" style="display: inline-block;"><input type="checkbox" class="toggle-notes" checked><span>Show notes</span></label>
-              <a href="@url(repository)/blob/@oldCommitId.get/@diff.oldPath" class="btn btn-small">View file @@ @oldCommitId.get.substring(0, 10)</a>
+              <a href="@url(repository)/blob/@oldCommitId.get/@diff.oldPath" class="btn btn-small" title="View the whole file at version @oldCommitId.get.substring(0, 10)" data-toggle="tooltip">View</a>
            </div>
          }
+          <span class="diffstat">
+            <img src="@assets/common/images/diff_delete.png"/>
+          </span> @diff.oldPath
        }
      </th>
    </tr>
    <tr>
      <td style="padding: 0;">
        @if(diff.newContent != None || diff.oldContent != None){
-          <div id="diffText-@i"></div>
-          <textarea id="newText-@i" style="display: none;">@diff.newContent.getOrElse("")</textarea>
-          <textarea id="oldText-@i" style="display: none;">@diff.oldContent.getOrElse("")</textarea>
+          <div id="diffText-@i" class="diffText"></div>
+          <textarea id="newText-@i" style="display: none;" data-file-name="@diff.oldPath">@diff.newContent.getOrElse("")</textarea>
+          <textarea id="oldText-@i" style="display: none;" data-file-name="@diff.newPath">@diff.oldContent.getOrElse("")</textarea>
        } else {
          Not supported
        }
@@ -92,7 +102,6 @@
  </table>
 }
 <script type="text/javascript" src="@assets/vendors/jsdifflib/difflib.js"></script>
-<script type="text/javascript" src="@assets/vendors/jsdifflib/diffview.js"></script>
 <link href="@assets/vendors/jsdifflib/diffview.css" type="text/css" rel="stylesheet" />
 <script>
 $(function(){
@@ -108,16 +117,26 @@ $(function(){
  }

  // Render diffs as unified mode initially
-  renderDiffs(1);
+  if(("&"+location.search.substring(1)).indexOf("&w=1")!=-1){
+    $('.ignore-whitespace').prop('checked',true);
+  }
+  window.viewType=1;
+  if(("&"+location.search.substring(1)).indexOf("&diff=split")!=-1){
+    $('.container').removeClass('container').addClass('container-wide');
+    window.viewType=0;
+  }
+  renderDiffs();

  $('#btn-unified').click(function(){
+    window.viewType=1;
    $('.container-wide').removeClass('container-wide').addClass('container');
-    renderDiffs(1);
+    renderDiffs();
  });

  $('#btn-split').click(function(){
+    window.viewType=0;
    $('.container').removeClass('container').addClass('container-wide');
-    renderDiffs(0);
+    renderDiffs();
  });

  $('.toggle-notes').change(function() {
@@ -126,126 +145,154 @@ $(function(){
    }
    $(this).closest('table').find('.not-diff').toggle();
  });
+  $('.ignore-whitespace').change(function() {
+    renderOneDiff($(this).closest("table").find(".diffText"), viewType);
+  });

-  function renderDiffs(viewType){
-    window.viewType = viewType;
-    @diffs.zipWithIndex.map { case (diff, i) =>
-      @if(diff.newContent != None || diff.oldContent != None){
-        if($('#oldText-@i').length > 0){
-          diffUsingJS('oldText-@i', 'newText-@i', 'diffText-@i', viewType);
+  function getInlineContainer(where) {
+    if (viewType == 0) {
+      if (where === 'new') {
+        return $('<tr class="not-diff"><td colspan="2"></td><td colspan="2" class="comment-box-container"></td></tr>');
+      } else if (where === 'old') {
+        return $('<tr class="not-diff"><td colspan="2" class="comment-box-container"></td><td colspan="2"></td></tr>');
+      }
+    }
+    return $('<tr class="not-diff"><td colspan="3" class="comment-box-container"></td></tr>');
+  }
+  if (typeof $('#show-notes')[0] !== 'undefined' && !$('#show-notes')[0].checked) {
+    $('.inline-comment').hide();
+  }
+  $('.diff-outside').on('click','table.diff .add-comment',function() {
+    var $this = $(this),
+    $tr = $this.closest('tr'),
+    $check = $this.closest('table:not(.diff)').find('.toggle-notes');
+    if (!$check.prop('checked')) {
+      $check.prop('checked', true).trigger('change');
+    }
+    if (!$tr.nextAll(':not(.not-diff):first').prev().hasClass('inline-comment-form')) {
+      var commitId = $this.closest('.table-bordered').attr('commitId'),
+      fileName = $this.closest('.table-bordered').attr('fileName'),
+      oldLineNumber, newLineNumber,
+      url = '@url(repository)/commit/' + commitId + '/comment/_form?fileName=' + fileName@issueId.map { id => + '&issueId=@id' };
+      if (viewType == 0) {
+        oldLineNumber = $this.parent().prev('.oldline').attr('line-number');
+        newLineNumber = $this.parent().prev('.newline').attr('line-number');
+      } else {
+        oldLineNumber = $this.parent().prevAll('.oldline').attr('line-number');
+        newLineNumber = $this.parent().prevAll('.newline').attr('line-number');
+      }
+      if (!isNaN(oldLineNumber) && oldLineNumber) {
+        url += ('&oldLineNumber=' + oldLineNumber)
+      }
+      if (!isNaN(newLineNumber) && newLineNumber) {
+        url += ('&newLineNumber=' + newLineNumber)
+      }
+      $.get(
+        url,
+        {
+          dataType : 'html'
+        },
+        function(responseContent) {
+          $this.hide();
+          var tmp;
+          if (!isNaN(oldLineNumber) && oldLineNumber) {
+            if (!isNaN(newLineNumber) && newLineNumber) {
+              tmp = getInlineContainer();
+            } else {
+              tmp = getInlineContainer('old');
+            }
+          } else {
+            tmp = getInlineContainer('new');
+          }
+          tmp.addClass('inline-comment-form').children('.comment-box-container').html(responseContent);
+          $tr.nextAll(':not(.not-diff):first').before(tmp);
+        }
+      );
+    }
+  }).on('click', 'table.diff .btn-default', function() {
+    $(this).closest('.inline-comment-form').remove();
+  });
+  function renderOneCommitCommentIntoDiff($v, diff){
+    var filename = $v.attr('filename'),
+    oldline = $v.attr('oldline'), newline = $v.attr('newline');
+    var tmp;
+    var diff;
+    if (typeof oldline !== 'undefined') {
+      if (typeof newline !== 'undefined') {
+        tmp = getInlineContainer();
+      } else {
+        tmp = getInlineContainer('old');
+      }
+      tmp.children('td:first').html($v.clone().show());
+      diff.find('table.diff').find('.oldline[line-number=' + oldline  + ']')
+      .parent().nextAll(':not(.not-diff):first').before(tmp);
+    } else {
+      tmp = getInlineContainer('new');
+      tmp.children('td:last').html($v.clone().show());
+      diff.find('table.diff').find('.newline[line-number=' + newline  + ']')
+      .parent().nextAll(':not(.not-diff):first').before(tmp);
+    }
+    if (!diff.find('.toggle-notes').prop('checked')) {
+      tmp.hide();
+    }
+  }
+  function renderStatBar(add,del){
+    if(add+del>5){
+      if(add){
+        if(add<del){
+          add = Math.floor(1 + (add * 4 / (add+del)));
+        }else{
+          add = Math.ceil(1 + (add * 4 / (add+del)));
        }
      }
+      del = 5-add;
+    }
+    var ret = $('<div class="diffstat-bar">');
+    for(var i=0;i<5;i++){
+      if(add){
+        ret.append('<span class="text-diff-added">■</span>');
+        add --;
+      }else if(del){
+        ret.append('<span class="text-diff-deleted">■</span>');
+        del --;
+      }else{
+        ret.append('■');
+      }
+    }
+    return ret;
+  }
+  function renderOneDiff(diffText, viewType){
+    var table = diffText.closest("table[data-diff-id]");
+    var i = table.data("diff-id");
+    var ignoreWhiteSpace = table.find('.ignore-whitespace').prop('checked');
+    diffUsingJS('oldText-'+i, 'newText-'+i, diffText.attr('id'), viewType, ignoreWhiteSpace);
+    var add = diffText.find("table").attr("add")*1;
+    var del = diffText.find("table").attr("del")*1;
+    table.find(".diffstat").text(add+del+" ").append(renderStatBar(add,del)).attr("title",add+" additions & "+del+" deletions").tooltip();
+    $('span.diffstat[data-diff-id="'+i+'"]').html('<span class="text-diff-added">+'+add+'</span><span class="text-diff-deleted">-'+del+'</span>').append(renderStatBar(add,del).attr('title',(add+del)+" lines changed").tooltip());
+
+    @if(hasWritePermission) {
+      diffText.find('.body').each(function(){ $('<b class="add-comment">+</b>').prependTo(this); });
    }
    @if(showLineNotes){
-      function getInlineContainer(where) {
-        if (viewType == 0) {
-          if (where === 'new') {
-            return $('<tr class="not-diff"><td colspan="2"></td><td colspan="2" class="comment-box-container"></td></tr>');
-          } else if (where === 'old') {
-            return $('<tr class="not-diff"><td colspan="2" class="comment-box-container"></td><td colspan="2"></td></tr>');
-          }
-        }
-        return $('<tr class="not-diff"><td colspan="3" class="comment-box-container"></td></tr>');
-      }
+      var fileName = table.attr('filename');
      $('.inline-comment').each(function(i, v) {
-        var $v = $(v), filename = $v.attr('filename'),
-        oldline = $v.attr('oldline'), newline = $v.attr('newline');
-        if (typeof $('#show-notes')[0] !== 'undefined' && !$('#show-notes')[0].checked) {
-          $(this).hide();
-        }
-        var tmp;
-        var diff;
-        if (typeof oldline !== 'undefined') {
-          if (typeof newline !== 'undefined') {
-            tmp = getInlineContainer();
-          } else {
-            tmp = getInlineContainer('old');
-          }
-          tmp.children('td:first').html($(this).clone().show());
-          diff = $('table[filename="' + filename + '"]');
-          diff.find('table.diff').find('.oldline[line-number=' + oldline  + ']')
-          .parent().nextAll(':not(.not-diff):first').before(tmp);
-        } else {
-          tmp = getInlineContainer('new');
-          tmp.children('td:last').html($(this).clone().show());
-          diff = $('table[filename="' + filename + '"]');
-          diff.find('table.diff').find('.newline[line-number=' + newline  + ']')
-          .parent().nextAll(':not(.not-diff):first').before(tmp);
-        }
-        if (!diff.find('.toggle-notes').prop('checked')) {
-          tmp.hide();
+        if($(this).attr('filename')==fileName){
+          renderOneCommitCommentIntoDiff($(this), table);
        }
      });
-      @if(hasWritePermission) {
-        $('table.diff td').hover(
-          function() {
-            $(this).find('b').css('display', 'inline-block');
-          },
-          function() {
-            $(this).find('b').css('display', 'none');
-          }
-        );
-        $('table.diff th').hover(
-          function() {
-            $(this).nextAll().find('b').first().css('display', 'inline-block');
-          },
-          function() {
-            $(this).nextAll().find('b').first().css('display', 'none');
-          }
-        );
-        $('.add-comment').click(function() {
-          var $this = $(this),
-          $tr = $this.closest('tr'),
-          $check = $this.closest('table:not(.diff)').find('.toggle-notes');
-          if (!$check.prop('checked')) {
-            $check.prop('checked', true).trigger('change');
-          }
-          if (!$tr.nextAll(':not(.not-diff):first').prev().hasClass('inline-comment-form')) {
-            var commitId = $this.closest('.table-bordered').attr('commitId'),
-            fileName = $this.closest('.table-bordered').attr('fileName'),
-            oldLineNumber, newLineNumber,
-            url = '@url(repository)/commit/' + commitId + '/comment/_form?fileName=' + fileName@issueId.map { id => + '&issueId=@id' };
-            if (viewType == 0) {
-              oldLineNumber = $this.parent().prev('.oldline').attr('line-number');
-              newLineNumber = $this.parent().prev('.newline').attr('line-number');
-            } else {
-              oldLineNumber = $this.parent().prevAll('.oldline').attr('line-number');
-              newLineNumber = $this.parent().prevAll('.newline').attr('line-number');
-            }
-            if (!isNaN(oldLineNumber) && oldLineNumber) {
-              url += ('&oldLineNumber=' + oldLineNumber)
-            }
-            if (!isNaN(newLineNumber) && newLineNumber) {
-              url += ('&newLineNumber=' + newLineNumber)
-            }
-            $.get(
-              url,
-              {
-                dataType : 'html'
-              },
-              function(responseContent) {
-                $this.hide();
-                var tmp;
-                if (!isNaN(oldLineNumber) && oldLineNumber) {
-                  if (!isNaN(newLineNumber) && newLineNumber) {
-                    tmp = getInlineContainer();
-                  } else {
-                    tmp = getInlineContainer('old');
-                  }
-                } else {
-                  tmp = getInlineContainer('new');
-                }
-                tmp.addClass('inline-comment-form').children('.comment-box-container').html(responseContent);
-                $tr.nextAll(':not(.not-diff):first').before(tmp);
-              }
-            );
-          }
-        });
-        $('table.diff').on('click', '.btn-default', function() {
-          $(this).closest('.inline-comment-form').remove();
-        });
+    }
+  }
+  function renderDiffs(){
+    var i=0, diffs = $('.diffText');
+    function render(){
+      if(diffs[i]){
+        renderOneDiff($(diffs[i]), viewType);
+        i++;
+        setTimeout(render);
      }
    }
+    render();
  }
 });
 </script>
--- a/src/main/twirl/gitbucket/core/issues/commentlist.scala.html
+++ b/src/main/twirl/gitbucket/core/issues/commentlist.scala.html
@@ -17,7 +17,7 @@
        }
      </span>
    </div>
-    <div class="box-content issue-content" id="issueContent">
+    <div class="box-content issue-content markdown-body" id="issueContent">
      @markdown(issue.get.content getOrElse "No description provided.", repository, false, true, true, hasWritePermission)
    </div>
  </div>
@@ -50,7 +50,7 @@
          @if(comment.action == "commit" && comment.content.split(" ").last.matches("[a-f0-9]{40}")){
            @defining(comment.content.substring(comment.content.length - 40)){ id =>
              <div class="pull-right"><a href="@path/@repository.owner/@repository.name/commit/@id" class="monospace">@id.substring(0, 7)</a></div>
-              @markdown(comment.content.substring(0, comment.content.length - 41), repository, false, true, true, hasWritePermission)
+              <div class="markdown-body">@markdown(comment.content.substring(0, comment.content.length - 41), repository, false, true, true, hasWritePermission)</div>
            }
          } else {
            @if(comment.action == "refer"){
@@ -58,7 +58,7 @@
                <strong><a href="@path/@repository.owner/@repository.name/issues/@issueId">Issue #@issueId</a>: @rest.mkString(":")</strong>
              }
            } else {
-              @markdown(comment.content, repository, false, true, true, hasWritePermission)
+                <div class="markdown-body">@markdown(comment.content, repository, false, true, true, hasWritePermission)</div>
            }
          }
        </div>
--- a/src/main/twirl/gitbucket/core/issues/commitstatus.scala.html
+++ b/src/main/twirl/gitbucket/core/issues/commitstatus.scala.html
@@ -0,0 +1,19 @@
+@(issue: gitbucket.core.model.Issue, statusInfo: Option[gitbucket.core.service.IssuesService.CommitStatusInfo])(implicit context: gitbucket.core.controller.Context)
+@import gitbucket.core.view.helpers._
+@statusInfo.map{ status =>
+  @if(status.count==1 && status.state.isDefined){
+    @if(status.targetUrl.isDefined){
+      <a href="@status.targetUrl.get" class="text-@status.state.get.name" data-toggle="tooltip" title="@status.state.get.name : @status.description.getOrElse(status.context.get)">@commitStateIcon(status.state.get)</a>
+    }else{
+      <span class="text-@status.state.get.name">@commitStateIcon(status.state.get)
+    }
+  }else{
+    @defining(status.count==status.successCount){ isSuccess =>
+    <a href="@context.path/@issue.userName/@issue.repositoryName/@issue.issueId" class="@if(isSuccess){ text-success }else{ text-error }" data-toggle="tooltip" title="@status.successCount / @status.count checks OK">@if(isSuccess){
+    	&#x2714;
+    }else{
+    	×
+    }</a>
+    }
+  }
+}
--- a/src/main/twirl/gitbucket/core/issues/listparts.scala.html
+++ b/src/main/twirl/gitbucket/core/issues/listparts.scala.html
@@ -11,12 +11,11 @@
  hasWritePermission: Boolean = false)(implicit context: gitbucket.core.controller.Context)
@import context._
@import gitbucket.core.view.helpers._
-@import gitbucket.core.service.IssuesService
@import gitbucket.core.service.IssuesService.IssueInfo
 <br>
@if(condition.nonEmpty){
  <div>
-    <a href="@IssuesService.IssueSearchCondition().toURL" class="header-link">
+    <a href="@gitbucket.core.service.IssuesService.IssueSearchCondition().toURL" class="header-link">
      <img src="@assets/common/images/clear.png" class="header-icon"/>
      <img src="@assets/common/images/clear_hover.png" class="header-icon-hover" style="display: none;"/>
      <span class="strong">Clear current search query, filters, and sorts</span>
@@ -26,10 +25,8 @@
 <table class="table table-bordered table-hover table-issues">
  <tr>
    <th style="background-color: #eee;">
-      @if(hasWritePermission){
-        <input type="checkbox"/>
-      }
-      <span class="small" id="table-issues-control">
+      <input type="checkbox"/>
+      <span class="small">
        <a class="button-link@if(condition.state == "open"){ selected}" href="@condition.copy(state = "open").toURL">
          <img src="@assets/common/images/status-open@(if(condition.state == "open"){"-active"}).png"/>
          @openCount Open
@@ -38,119 +35,116 @@
          <img src="@assets/common/images/status-closed@(if(condition.state == "closed"){"-active"}).png"/>
          @closedCount Closed
        </a>
-        <div class="pull-right">
-          @helper.html.dropdown("Author", flat = true) {
-            @collaborators.map { collaborator =>
-              <li>
-                <a href="@condition.copy(author = (if(condition.author == Some(collaborator)) None else Some(collaborator))).toURL">
-                  @helper.html.checkicon(condition.author == Some(collaborator))
-                  @avatar(collaborator, 20) @collaborator
-                </a>
-              </li>
-            }
+      </span>
+      <div class="pull-right" id="table-issues-control">
+        @helper.html.dropdown("Author", flat = true) {
+          @collaborators.map { collaborator =>
+            <li>
+              <a href="@condition.copy(author = (if(condition.author == Some(collaborator)) None else Some(collaborator))).toURL">
+                @helper.html.checkicon(condition.author == Some(collaborator))
+                @avatar(collaborator, 20) @collaborator
+              </a>
+            </li>
+          }
+        }
+        @helper.html.dropdown("Label", flat = true) {
+          @labels.map { label =>
+            <li>
+              <a href="@condition.copy(labels = (if(condition.labels.contains(label.labelName)) condition.labels - label.labelName else condition.labels + label.labelName)).toURL">
+                @helper.html.checkicon(condition.labels.contains(label.labelName))
+                <span style="background-color: #@label.color;" class="label-color">&nbsp;&nbsp;</span>
+                @label.labelName
+              </a>
+            </li>
+          }
+        }
+        @helper.html.dropdown("Milestone", flat = true) {
+          <li>
+            <a href="@condition.copy(milestone = Some(None)).toURL">
+              @helper.html.checkicon(condition.milestone == Some(None)) Issues with no milestone
+            </a>
+          </li>
+          @milestones.filter(_.closedDate.isEmpty).map { milestone =>
+            <li>
+              <a href="@condition.copy(milestone = Some(Some(milestone.title))).toURL">
+                @helper.html.checkicon(condition.milestone == Some(Some(milestone.title))) @milestone.title
+              </a>
+            </li>
+          }
+        }
+        @helper.html.dropdown("Assignee", flat = true) {
+          @collaborators.map { collaborator =>
+            <li>
+              <a href="@condition.copy(assigned = Some(collaborator)).toURL">
+                @helper.html.checkicon(condition.assigned == Some(collaborator))
+                @avatar(collaborator, 20) @collaborator
+              </a>
+            </li>
+          }
+        }
+        @helper.html.dropdown("Sort", flat = true){
+          <li>
+            <a href="@condition.copy(sort="created",  direction="desc").toURL">
+            @helper.html.checkicon(condition.sort == "created"  && condition.direction == "desc") Newest
+            </a>
+          </li>
+          <li>
+            <a href="@condition.copy(sort="created",  direction="asc" ).toURL">
+            @helper.html.checkicon(condition.sort == "created"  && condition.direction == "asc") Oldest
+            </a>
+          </li>
+          <li>
+            <a href="@condition.copy(sort="comments", direction="desc").toURL">
+            @helper.html.checkicon(condition.sort == "comments"  && condition.direction == "desc") Most commented
+            </a>
+          </li>
+          <li>
+            <a href="@condition.copy(sort="comments", direction="asc" ).toURL">
+            @helper.html.checkicon(condition.sort == "comments"  && condition.direction == "asc") Least commented
+            </a>
+          </li>
+          <li>
+            <a href="@condition.copy(sort="updated",  direction="desc").toURL">
+            @helper.html.checkicon(condition.sort == "updated"  && condition.direction == "desc") Recently updated
+            </a>
+          </li>
+          <li>
+            <a href="@condition.copy(sort="updated",  direction="asc" ).toURL">
+            @helper.html.checkicon(condition.sort == "updated"  && condition.direction == "asc") Least recently updated
+            </a>
+          </li>
+        }
+      </div>
+      @if(hasWritePermission){
+        <div class="pull-right" id="table-issues-batchedit">
+          @helper.html.dropdown("Mark as", flat = true) {
+            <li><a href="javascript:void(0);" class="toggle-state" data-id="open">Open</a></li>
+            <li><a href="javascript:void(0);" class="toggle-state" data-id="close">Close</a></li>
          }
          @helper.html.dropdown("Label", flat = true) {
            @labels.map { label =>
              <li>
-                <a href="@condition.copy(labels = (if(condition.labels.contains(label.labelName)) condition.labels - label.labelName else condition.labels + label.labelName)).toURL">
-                  @helper.html.checkicon(condition.labels.contains(label.labelName))
-                  <span style="background-color: #@label.color;" class="label-color">&nbsp;&nbsp;</span>
+                <a href="javascript:void(0);" class="toggle-label" data-id="@label.labelId">
+                  <i class="icon-white"></i>
+                  <span class="label" style="background-color: #@label.color;">&nbsp;</span>
                  @label.labelName
                </a>
              </li>
            }
          }
          @helper.html.dropdown("Milestone", flat = true) {
-            <li>
-              <a href="@condition.copy(milestone = Some(None)).toURL">
-                @helper.html.checkicon(condition.milestone == Some(None)) Issues with no milestone
-              </a>
-            </li>
+            <li><a href="javascript:void(0);" class="toggle-milestone" data-id="">No milestone</a></li>
            @milestones.filter(_.closedDate.isEmpty).map { milestone =>
-              <li>
-                <a href="@condition.copy(milestone = Some(Some(milestone.title))).toURL">
-                  @helper.html.checkicon(condition.milestone == Some(Some(milestone.title))) @milestone.title
-                </a>
-              </li>
+              <li><a href="javascript:void(0);" class="toggle-milestone" data-id="@milestone.milestoneId">@milestone.title</a></li>
            }
          }
          @helper.html.dropdown("Assignee", flat = true) {
+            <li><a href="javascript:void(0);" class="toggle-assign" data-name=""><i class="icon-remove-circle"></i> Clear assignee</a></li>
            @collaborators.map { collaborator =>
-              <li>
-                <a href="@condition.copy(assigned = Some(collaborator)).toURL">
-                  @helper.html.checkicon(condition.assigned == Some(collaborator))
-                  @avatar(collaborator, 20) @collaborator
-                </a>
-              </li>
+              <li><a href="javascript:void(0);" class="toggle-assign" data-name="@collaborator"><i class="icon-white"></i>@avatar(collaborator, 20) @collaborator</a></li>
            }
          }
-          @helper.html.dropdown("Sort", flat = true){
-            <li>
-              <a href="@condition.copy(sort="created",  direction="desc").toURL">
-              @helper.html.checkicon(condition.sort == "created"  && condition.direction == "desc") Newest
-              </a>
-            </li>
-            <li>
-              <a href="@condition.copy(sort="created",  direction="asc" ).toURL">
-              @helper.html.checkicon(condition.sort == "created"  && condition.direction == "asc") Oldest
-              </a>
-            </li>
-            <li>
-              <a href="@condition.copy(sort="comments", direction="desc").toURL">
-              @helper.html.checkicon(condition.sort == "comments"  && condition.direction == "desc") Most commented
-              </a>
-            </li>
-            <li>
-              <a href="@condition.copy(sort="comments", direction="asc" ).toURL">
-              @helper.html.checkicon(condition.sort == "comments"  && condition.direction == "asc") Least commented
-              </a>
-            </li>
-            <li>
-              <a href="@condition.copy(sort="updated",  direction="desc").toURL">
-              @helper.html.checkicon(condition.sort == "updated"  && condition.direction == "desc") Recently updated
-              </a>
-            </li>
-            <li>
-              <a href="@condition.copy(sort="updated",  direction="asc" ).toURL">
-              @helper.html.checkicon(condition.sort == "updated"  && condition.direction == "asc") Least recently updated
-              </a>
-            </li>
-          }
        </div>
-      </span>
-      @if(hasWritePermission){
-        <span class="small" id="table-issues-batchedit">
-          <span id="batchedit-selected"></span> selected
-          <div class="pull-right">
-            @helper.html.dropdown("Mark as", flat = true) {
-              <li><a href="javascript:void(0);" class="toggle-state" data-id="open">Open</a></li>
-              <li><a href="javascript:void(0);" class="toggle-state" data-id="close">Close</a></li>
-            }
-            @helper.html.dropdown("Label", flat = true) {
-              @labels.map { label =>
-                <li>
-                  <a href="javascript:void(0);" class="toggle-label" data-id="@label.labelId">
-                    <i class="icon-white"></i>
-                    <span class="label" style="background-color: #@label.color;">&nbsp;</span>
-                    @label.labelName
-                  </a>
-                </li>
-              }
-            }
-            @helper.html.dropdown("Milestone", flat = true) {
-              <li><a href="javascript:void(0);" class="toggle-milestone" data-id="">No milestone</a></li>
-              @milestones.filter(_.closedDate.isEmpty).map { milestone =>
-                <li><a href="javascript:void(0);" class="toggle-milestone" data-id="@milestone.milestoneId">@milestone.title</a></li>
-              }
-            }
-            @helper.html.dropdown("Assign", flat = true) {
-              <li><a href="javascript:void(0);" class="toggle-assign" data-name="">Assign to nobody</a></li>
-              @collaborators.map { collaborator =>
-                <li><a href="javascript:void(0);" class="toggle-assign" data-name="@collaborator"><i class="icon-white"></i>@avatar(collaborator, 20) @collaborator</a></li>
-              }
-            }
-          </div>
-        </span>
      }
    </th>
  </tr>
@@ -176,7 +170,7 @@
      </td>
    </tr>
  }
-  @issues.map { case IssueInfo(issue, labels, milestone, commentCount) =>
+  @issues.map { case IssueInfo(issue, labels, milestone, commentCount, commitStatus) =>
    <tr>
      <td style="padding-top: 15px; padding-bottom: 15px;">
        @if(hasWritePermission){
@@ -191,6 +185,7 @@
        } else {
          <a href="@path/@issue.userName/@issue.repositoryName/pull/@issue.issueId" class="issue-title">@issue.title</a>
        }
+        @commitstatus(issue, commitStatus)
        @labels.map { label =>
          <span class="label-color small" style="background-color: #@label.color; color: #@label.fontColor; padding-left: 4px; padding-right: 4px">@label.labelName</span>
        }
@@ -219,6 +214,6 @@
  }
 </table>
 <div class="pull-right">
-  @helper.html.paginator(page, (if(condition.state == "open") openCount else closedCount), IssuesService.IssueLimit, 10, condition.toURL)
+  @helper.html.paginator(page, (if(condition.state == "open") openCount else closedCount), gitbucket.core.service.IssuesService.IssueLimit, 10, condition.toURL)
 </div>

--- a/src/main/twirl/gitbucket/core/issues/milestones/list.scala.html
+++ b/src/main/twirl/gitbucket/core/issues/milestones/list.scala.html
@@ -31,7 +31,7 @@
          <td style="padding-top: 15px; padding-bottom: 15px;">
            <div class="milestone row-fluid">
              <div class="span4">
-                <a href="@url(repository)/issues?milestone=@milestone.milestoneId&state=open" class="milestone-title">@milestone.title</a>
+                <a href="@url(repository)/issues?milestone=@milestone.title&state=open" class="milestone-title">@milestone.title</a>
                <div style="margin-top: 6px">
                  @if(milestone.closedDate.isDefined){
                    <span class="muted">Closed @helper.html.datetimeago(milestone.closedDate.get)</span>
@@ -75,7 +75,7 @@
              </div>
            </div>
            @if(milestone.description.isDefined){
-              <div class="milestone-description">
+              <div class="milestone-description markdown-body">
                @markdown(milestone.description.get, repository, false, false)
              </div>
            }
--- a/src/main/twirl/gitbucket/core/menu.scala.html
+++ b/src/main/twirl/gitbucket/core/menu.scala.html
@@ -182,7 +182,7 @@ $(function(){

  $('a[rel*=facebox]').facebox({
    'loadingImage': '@assets/vendors/facebox/loading.gif',
-    'closeImage': '@assets/vendors/facebox/closelabel.png',
+    'closeImage': '@assets/vendors/facebox/closelabel.png'
  });

  $(document).on("click", ".js-fork-owner-select-target", function() {
--- a/src/main/twirl/gitbucket/core/pulls/conversation.scala.html
+++ b/src/main/twirl/gitbucket/core/pulls/conversation.scala.html
@@ -10,35 +10,21 @@
@import context._
@import gitbucket.core.view.helpers._
@import gitbucket.core.model._
+
 <div class="row-fluid">
  <div class="span10">
    <div id="comment-list">
      @issues.html.commentlist(Some(issue), comments, hasWritePermission, repository, Some(pullreq))
    </div>
    @defining(comments.flatMap {
-      case comment: IssueComment => Some(comment)
+      case comment: gitbucket.core.model.IssueComment => Some(comment)
      case other => None
    }.exists(_.action == "merge")){ merged =>
      @if(hasWritePermission && !issue.closed){
-        <div class="box issue-comment-box" style="background-color: #d8f5cd;">
-          <div class="box-content"class="issue-content" style="border: 1px solid #95c97e; padding: 10px;">
-            <div id="merge-pull-request">
-              <div class="check-conflict" style="display: none;">
-                <img src="@assets/common/images/indicator.gif"/> Checking...
-              </div>
-            </div>
-            <div id="confirm-merge-form" style="display: none;">
-              <form method="POST" action="@url(repository)/pull/@issue.issueId/merge">
-                <div class="strong">
-                  Merge pull request #@issue.issueId from @{pullreq.requestUserName}/@{pullreq.requestBranch}
-                </div>
-                <span id="error-message" class="error"></span>
-                <textarea name="message" style="width: 635px; height: 80px;">@issue.title</textarea>
-                <div>
-                  <input type="button" class="btn" value="Cancel" id="cancel-merge-pull-request"/>
-                  <input type="submit" class="btn btn-success" value="Confirm merge"/>
-                </div>
-              </form>
+        <div class="check-conflict" style="display: none;">
+          <div class="box issue-comment-box" style="background-color: #fbeed5">
+            <div class="box-content"class="issue-content" style="border: 1px solid #c09853; padding: 10px;">
+              <img src="@assets/common/images/indicator.gif"/> Checking...
            </div>
          </div>
        </div>
--- a/src/main/twirl/gitbucket/core/pulls/mergeguide.scala.html
+++ b/src/main/twirl/gitbucket/core/pulls/mergeguide.scala.html
@@ -1,17 +1,60 @@
@(hasConflict: Boolean,
+  hasProblem: Boolean,
+  issue: gitbucket.core.model.Issue,
  pullreq: gitbucket.core.model.PullRequest,
+  statuses: List[model.CommitStatus],
+  repository: gitbucket.core.service.RepositoryService.RepositoryInfo,
  requestRepositoryUrl: String)(implicit context: gitbucket.core.controller.Context)
@import context._
@import gitbucket.core.view.helpers._
+@import model.CommitState
+<div class="box issue-comment-box" style="background-color: @if(hasProblem){ #fbeed5 }else{ #d8f5cd };">
+  <div class="box-content"class="issue-content" style="border: 1px solid @if(hasProblem){ #c09853 }else{ #95c97e }; padding: 10px;">
+    <div id="merge-pull-request">
+      @if(!statuses.isEmpty){
+        <div class="build-statuses">
+          @if(statuses.size==1){
+            @defining(statuses.head){ status =>
+            <div class="build-status-item">
+              @status.targetUrl.map{ url => <a class="pull-right" href="@url">Details</a> }
+              <span class="build-status-icon text-@{status.state.name}">@commitStateIcon(status.state)</span>
+              <strong class="text-@{status.state.name}">@commitStateText(status.state, pullreq.commitIdTo)</strong>
+              @status.description.map{ desc => <span class="muted">— @desc</span> }
+            </div>
+            }
+          }else{
+            @defining(statuses.groupBy(_.state)){ stateMap => @defining(CommitState.combine(stateMap.keySet)){ state =>
+              <div class="build-status-item">
+                <a class="pull-right" id="toggle-all-checks"></a>
+                <span class="build-status-icon text-@{state.name}">@commitStateIcon(state)</span>
+                <strong class="text-@{state.name}">@commitStateText(state, pullreq.commitIdTo)</strong>
+                <span class="text-@{state.name}">— @{stateMap.map{ case (keyState, states) => states.size+" "+keyState.name }.mkString(", ")} checks</span>
+              </div>
+              <div class="build-statuses-list" style="@if(state==CommitState.SUCCESS){ display:none; }else{ }">
+                @statuses.map{ status =>
+                <div class="build-status-item">
+                  @status.targetUrl.map{ url => <a class="pull-right" href="@url">Details</a> }
+                  <span class="build-status-icon text-@{status.state.name}">@commitStateIcon(status.state)</span>
+                  <span class="text-@{status.state.name}">@status.context</span>
+                  @status.description.map{ desc => <span class="muted">— @desc</span> }
+                </div>
+                }
+              </div>
+            } }
+          }
+        </div>
+      }
 <div class="pull-right">
-  <input type="button" class="btn btn-success" id="merge-pull-request-button" value="Merge pull request"@if(hasConflict){ disabled="true"}/>
+  <input type="button" class="btn @if(!hasProblem){ btn-success }" id="merge-pull-request-button" value="Merge pull request"@if(hasConflict){ disabled="true"}/>
 </div>
 <div>
  @if(hasConflict){
    <span class="strong">We can’t automatically merge this pull request.</span>
+  } else{ @if(hasProblem){
+    <span class="strong">Merge with caution!</span>
  } else {
    <span class="strong">This pull request can be automatically merged.</span>
-  }
+  } }
 </div>
 <div class="small">
  @if(hasConflict){
@@ -69,12 +112,38 @@
    }
  </div>
 </div>
+
+    </div>
+    <div id="confirm-merge-form" style="display: none;">
+      <form method="POST" action="@url(repository)/pull/@pullreq.issueId/merge">
+        <div class="strong">
+          Merge pull request #@issue.issueId from @{pullreq.requestUserName}/@{pullreq.requestBranch}
+        </div>
+        <span id="error-message" class="error"></span>
+        <textarea name="message" style="width: 635px; height: 80px;">@issue.title</textarea>
+        <div>
+          <input type="button" class="btn" value="Cancel" id="cancel-merge-pull-request"/>
+          <input type="submit" class="btn btn-success" value="Confirm merge"/>
+        </div>
+      </form>
+    </div>
+  </div>
+</div>
+
 <script>
 $(function(){
  $('#show-command-line').click(function(){
    $('#command-line').show();
    return false;
  });
+  function setToggleAllChecksLabel(){
+    $("#toggle-all-checks").text($('.build-statuses-list').is(":visible") ? "Hide all checks" : "Show all checks");
+  }
+  setToggleAllChecksLabel();
+  $('#toggle-all-checks').click(function(){
+    $('.build-statuses-list').toggle();
+    setToggleAllChecksLabel();
+  })

  $('#merge-pull-request-button').click(function(){
    $('#merge-pull-request').hide();
--- a/src/main/twirl/gitbucket/core/repo/delete.scala.html
+++ b/src/main/twirl/gitbucket/core/repo/delete.scala.html
@@ -28,8 +28,8 @@
        <tr>
          <td>
            <div id="diffText"></div>
-            <textarea id="newText" style="display: none;"></textarea>
-            <textarea id="oldText" style="display: none;">@content.content</textarea>
+            <textarea id="newText" style="display: none;" data-file-name="@fileName"></textarea>
+            <textarea id="oldText" style="display: none;" data-file-name="@fileName">@content.content</textarea>
          </td>
        </tr>
      </table>
@@ -52,7 +52,6 @@
  }
 }
 <script type="text/javascript" src="@assets/vendors/jsdifflib/difflib.js"></script>
-<script type="text/javascript" src="@assets/vendors/jsdifflib/diffview.js"></script>
 <link href="@assets/vendors/jsdifflib/diffview.css" type="text/css" rel="stylesheet" />
 <script>
 $(function(){
--- a/src/main/twirl/gitbucket/core/repo/editor.scala.html
+++ b/src/main/twirl/gitbucket/core/repo/editor.scala.html
@@ -71,7 +71,6 @@
 }
 <script src="@assets/vendors/ace/ace.js" type="text/javascript" charset="utf-8"></script>
 <script type="text/javascript" src="@assets/vendors/jsdifflib/difflib.js"></script>
-<script type="text/javascript" src="@assets/vendors/jsdifflib/diffview.js"></script>
 <link href="@assets/vendors/jsdifflib/diffview.css" type="text/css" rel="stylesheet" />
 <script>
 $(function(){
@@ -138,8 +137,8 @@ $(function(){
      // Show diff
      $('#preview').empty()
        .append($('<div id="diffText">'))
-        .append($('<textarea id="newText" style="display: none;">').html(editor.getValue()))
-        .append($('<textarea id="oldText" style="display: none;">').html($('#initial').val()));
+        .append($('<textarea id="newText" style="display: none;">').data('file-name',$("#newFileName").val()).html(editor.getValue()))
+        .append($('<textarea id="oldText" style="display: none;">').data('file-name',$("#oldFileName").val()).html($('#initial').val()));
      diffUsingJS('oldText', 'newText', 'diffText', 1);
    }
  });
--- a/Show More
+++ b/Show More