Support Scala 2.12 (#115)

* #109 separate projects

* #109 support Scala 2.12

Author: tsuyoshizawa

.travis.yml

@@ -1,6 +1,7 @@
 language: scala
 scala:
-  - 2.11.7
+  - 2.12.1
+  - 2.11.8
 jdk:
   - oraclejdk8
 notifications:

README.md

@@ -19,38 +19,18 @@ and an access token type called [Bearer](http://tools.ietf.org/html/rfc6750).
 
 ## Setup
 
-If you'd like to use this with Play Framework, add "play2-oauth2-provider" to library dependencies of your project.
-
 ### Play Framework
 
-```scala
-libraryDependencies ++= Seq(
-  "com.nulab-inc" %% "play2-oauth2-provider" % "1.2.0"
-)
-```
-
-Library version | Play version
---------------- | ------------
-1.2.0           | 2.5.x
-0.16.1          | 2.4.x
-0.14.0          | 2.3.x
-0.7.4           | 2.2.x
+See [the project](https://github.com/nulab/play2-oauth2-provider)
 
 ### Akka HTTP
 
-```scala
-libraryDependencies ++= Seq(
-  "com.nulab-inc" %% "akka-http-oauth2-provider" % "1.2.0"
-)
-```
-
-Library version | Akka HTTP version
---------------- | ------------
-1.2.0           | 2.4.x
+See [the project](https://github.com/nulab/akka-http-oauth2-provider)
 
 ### Other frameworks
 
-Add `scala-oauth2-core` instead. In this case, you need to implement your own OAuth provider working with web framework you use.
+Add `scala-oauth2-core` library dependencies of your project.
+In this case, you need to implement your own OAuth provider working with web framework you use.
 
 ```scala
 libraryDependencies ++= Seq(
@@ -120,116 +100,3 @@ case class AuthInfo[User](
   - inform the client of the scope of the access token issued
 - redirectUri
   - This value must be enabled on authorization code grant
-
-### Work with Play Framework
-
-You should follow four steps below to work with Play Framework.
-
-* Customizing Grant Handlers
-* Define a controller to issue access token
-* Assign a route to the controller
-* Access to an authorized resource
-
-You want to use which grant types are supported or to use a customized handler for a grant type, you should override the ```handlers``` map in a customized ```TokenEndpoint``` trait.
-
-```scala
-class MyTokenEndpoint extends TokenEndpoint {
-  override val handlers = Map(
-    OAuthGrantType.AUTHORIZATION_CODE -> new AuthorizationCode(),
-    OAuthGrantType.REFRESH_TOKEN -> new RefreshToken(),
-    OAuthGrantType.CLIENT_CREDENTIALS -> new ClientCredentials(),
-    OAuthGrantType.PASSWORD -> new Password(),
-    OAuthGrantType.IMPLICIT -> new Implicit()
-  )
-}
-```
-
-Here's an example of a customized ```TokenEndpoint``` that 1) only supports the ```password``` grant type, and 2) customizes the ```password``` grant type handler to not require client credentials:
-
-```scala
-class MyTokenEndpoint extends TokenEndpoint {
-  val passwordNoCred = new Password() {
-    override def clientCredentialRequired = false
-  }
-
-  override val handlers = Map(
-    OAuthGrantType.PASSWORD -> passwordNoCred
-  )
-}
-```
-
-Define your own controller with mixining ```OAuth2Provider``` trait provided by this library to issue access token with customized `TokenEndpoint`.
-
-```scala
-import scalaoauth2.provider._
-object OAuth2Controller extends Controller with OAuth2Provider {
-  override val tokenEndpoint = new MyTokenEndpoint()
-
-  def accessToken = Action.async { implicit request =>
-    issueAccessToken(new MyDataHandler())
-  }
-}
-```
-
-Then, assign a route to the controller that OAuth clients will access to.
-
-```
-POST    /oauth2/access_token                    controllers.OAuth2Controller.accessToken
-```
-
-Finally, you can access to an authorized resource like this:
-
-```scala
-import scalaoauth2.provider._
-object MyController extends Controller with OAuth2Provider {
-  def list = Action.async { implicit request =>
-    authorize(new MyDataHandler()) { authInfo =>
-      val user = authInfo.user // User is defined on your system
-      // access resource for the user
-    }
-  }
-}
-```
-
-If you'd like to change the OAuth workflow, modify handleRequest methods of `TokenEndPoint` and `ProtectedResource` traits.
-
-### Using Action composition
-
-You can write more easily authorize action by using Action composition.
-
-Play Framework's documentation is [here](https://www.playframework.com/documentation/2.5.x/ScalaActionsComposition).
-
-```scala
-object MyController extends Controller {
-
-  import scalaoauth2.provider.OAuth2ProviderActionBuilders._
-
-  def list = AuthorizedAction(new MyDataHandler()) { request =>
-    val user = request.authInfo.user // User is defined on your system
-    // access resource for the user
-  }
-}
-```
-
-## Examples
-
-### Play Framework 2.5
-
-- https://github.com/lglossman/scala-oauth2-deadbolt-redis
-- https://github.com/tsuyoshizawa/scala-oauth2-provider-example-skinny-orm
-
-### Play Framework 2.3
-
-- https://github.com/davidseth/scala-oauth2-provider-slick
-
-### Play Framework 2.2
-
-- https://github.com/oyediyildiz/scala-oauth2-provider-example
-- https://github.com/tuxdna/play-oauth2-server
-
-## Application using this library
-
-- [Typetalk](https://typetalk.in/)
-- [Backlog](https://backlogtool.com/)
-- [Flic by Shortcut Labs](
-)