Split lib from examples (#8)

* split lib from example

* Removing the play dependency on core module

* Remove playJdbc and anorm dependencies on core

* Reformatting code

* Fix missing jdbc dependency

* Remove version per project in build.sbt

* Change organization domain

* Cleaning: delete utils package

* Fully qualified package name with organization name

* update package name + projects arborescence

Author: stankoua

app/database/package.scala

@@ -1,56 +1,83 @@
+import Dependencies._
+
 name := """query-monad-code"""
 
 version := "1.0-SNAPSHOT"
 
-lazy val root = (project in file(".")).enablePlugins(PlayScala)
-
 scalaVersion := "2.12.4"
 
-libraryDependencies ++= Seq(
-  jdbc,
-  "org.playframework.anorm" %% "anorm" % "2.6.0",
-  "org.typelevel" %% "cats-core" % "1.0.1",
-  "org.scalatestplus.play" %% "scalatestplus-play" % "3.1.1" % Test
+// Common values
+val commonSettings = Seq(
+  organization := "com.zengularity",
+  scalaVersion := "2.12.4",
+  crossPaths := false,
+  scalacOptions ++= Seq(
+    "-deprecation", // Emit warning and location for usages of deprecated APIs.
+    "-encoding",
+    "utf-8", // Specify character encoding used by source files.
+    "-explaintypes", // Explain type errors in more detail.
+    "-feature", // Emit warning and location for usages of features that should be imported explicitly.
+    "-unchecked", // Enable additional warnings where generated code depends on assumptions.
+    "-Xcheckinit", // Wrap field accessors to throw an exception on uninitialized access.
+    "-Xfatal-warnings", // Fail the compilation if there are any warnings.
+    "-Xlint",
+    "-Yno-adapted-args", // Do not adapt an argument list (either by inserting () or creating a tuple) to match the receiver.
+    "-Ypartial-unification", // Enable partial unification in type constructor inference
+    "-Ywarn-dead-code", // Warn when dead code is identified.
+    "-Ywarn-extra-implicit", // Warn when more than one implicit parameter section is defined.
+    "-Ywarn-inaccessible", // Warn about inaccessible types in method signatures.
+    "-Ywarn-infer-any", // Warn when a type argument is inferred to be `Any`.
+    "-Ywarn-nullary-override", // Warn when non-nullary `def f()' overrides nullary `def f'.
+    "-Ywarn-nullary-unit", // Warn when nullary methods return Unit.
+    "-Ywarn-numeric-widen", // Warn when numerics are widened.
+    "-Ywarn-unused", // Warn if unused.
+    "-Ywarn-value-discard" // Warn when non-Unit expression results are unused.
+  ),
+  scalacOptions in (Compile, console) ~= (_.filterNot(
+    Set(
+      "-Ywarn-unused:imports",
+      "-Xfatal-warnings"
+    ))),
+  scalacOptions in (Test, compile) ~= (_.filterNot(
+    Set(
+      "-Ywarn-unused:imports",
+      "-Xfatal-warnings"
+    ))),
+  resolvers ++= Seq[Resolver](
+    Resolver.sonatypeRepo("releases")
+  )
 )
 
-wartremoverErrors ++= Warts.unsafe
+scalafmtOnCompile := true
+scalafmtConfig := file("project/scalafmt.conf")
 
-scalacOptions ++= Seq(
-  "-deprecation", // Emit warning and location for usages of deprecated APIs.
-  "-encoding",
-  "utf-8", // Specify character encoding used by source files.
-  "-explaintypes", // Explain type errors in more detail.
-  "-feature", // Emit warning and location for usages of features that should be imported explicitly.
-  "-unchecked", // Enable additional warnings where generated code depends on assumptions.
-  "-Xcheckinit", // Wrap field accessors to throw an exception on uninitialized access.
-  "-Xfatal-warnings", // Fail the compilation if there are any warnings.
-  "-Xlint",
-  "-Yno-adapted-args", // Do not adapt an argument list (either by inserting () or creating a tuple) to match the receiver.
-  "-Ypartial-unification", // Enable partial unification in type constructor inference
-  "-Ywarn-dead-code", // Warn when dead code is identified.
-  "-Ywarn-extra-implicit", // Warn when more than one implicit parameter section is defined.
-  "-Ywarn-inaccessible", // Warn about inaccessible types in method signatures.
-  "-Ywarn-infer-any", // Warn when a type argument is inferred to be `Any`.
-  "-Ywarn-nullary-override", // Warn when non-nullary `def f()' overrides nullary `def f'.
-  "-Ywarn-nullary-unit", // Warn when nullary methods return Unit.
-  "-Ywarn-numeric-widen", // Warn when numerics are widened.
-  "-Ywarn-unused", // Warn if unused.
-  "-Ywarn-value-discard" // Warn when non-Unit expression results are unused.
-)
+wartremoverErrors ++= Warts.unsafe
 
-scalacOptions in (Compile, console) ~= (_.filterNot(
-  Set(
-    "-Ywarn-unused:imports",
-    "-Xfatal-warnings"
-  )))
+// Projects definitions
 
-scalacOptions in (Test, compile) ~= (_.filterNot(
-  Set(
-    "-Ywarn-unused:imports",
-    "-Xfatal-warnings"
-  )))
+lazy val core = (project in file("core"))
+  .settings(commonSettings)
+  .settings(
+    name := "query-core",
+    libraryDependencies ++= Seq(
+      Dependencies.cats
+    )
+  )
 
-scalafmtOnCompile := true
-scalafmtConfig := file("project/scalafmt.conf")
+lazy val sampleAppExample = (project in file("examples/sample-app"))
+  .enablePlugins(PlayScala)
+  .settings(commonSettings)
+  .settings(
+    name := "sample-app-example",
+    libraryDependencies ++= Seq(
+      jdbc,
+      Dependencies.anorm,
+      Dependencies.h2,
+      Dependencies.scalaTestPlusPlay
+    )
+  )
+  .dependsOn(core)
 
-wartremoverErrors in (Compile, compile) ++= Warts.unsafe
+lazy val root: Project = project
+  .in(file("."))
+  .aggregate(core, sampleAppExample)

app/utils/ReaderT.scala

@@ -0,0 +1,56 @@
+package com.zengularity.querymonad.core.database
+
+import java.sql.Connection
+import javax.sql.DataSource
+
+import scala.util.control.ControlThrowable
+
+/**
+  * This class is copy from Play DefaultDatabase class.
+  * See https://github.com/playframework/playframework/blob/master/framework/src/play-jdbc/src/main/scala/play/api/db/Databases.scala#L94
+  *
+  * @dataSource managed dataSource used to obtain connection.
+  */
+class Database(dataSource: DataSource) {
+
+  def getConnection(autocommit: Boolean): Connection = {
+    val connection = dataSource.getConnection
+    connection.setAutoCommit(autocommit)
+    connection
+  }
+
+  def withConnection[A](block: Connection => A): A = {
+    withConnection(autocommit = true)(block)
+  }
+
+  def withConnection[A](autocommit: Boolean)(block: Connection => A): A = {
+    val connection = getConnection(autocommit)
+    try {
+      block(connection)
+    } finally {
+      connection.close()
+    }
+  }
+
+  def withTransaction[A](block: Connection => A): A = {
+    withConnection(autocommit = false) { connection =>
+      try {
+        val r = block(connection)
+        connection.commit()
+        r
+      } catch {
+        case e: ControlThrowable =>
+          connection.commit()
+          throw e
+        case e: Throwable =>
+          connection.rollback()
+          throw e
+      }
+    }
+  }
+
+}
+
+object Database {
+  def apply(dataSource: DataSource): Database = new Database(dataSource)
+}

app/utils/package.scala

@@ -1,26 +1,29 @@
-package database
+package com.zengularity.querymonad.core.database
 
-import scala.concurrent.{ExecutionContext, Future}
+import javax.sql.DataSource
 
-import play.api.db.Database
+import scala.concurrent.{ExecutionContext, Future}
 
-class QueryRunner[DB <: Database](
+class QueryRunner(
     db: Database,
     ec: ExecutionContext
 ) {
   def run[A](query: Query[A]): Future[A] =
     Future {
-      db.withConnection(query.f)
+      db.withConnection(query.run)
     }(ec)
 
   // TODO: Remove with a transaction run at context level
   def commit[A](query: Query[A]): Future[A] =
     Future {
-      db.withTransaction(query.f)
+      db.withTransaction(query.run)
     }(ec)
 }
 
 object QueryRunner {
-  def apply[DB <: Database](db: Database, ec: ExecutionContext) =
+  def apply(db: Database, ec: ExecutionContext) =
     new QueryRunner(db, ec)
+
+  def apply(ds: DataSource, ec: ExecutionContext) =
+    new QueryRunner(Database(ds), ec)
 }

build.sbt

@@ -0,0 +1,34 @@
+package com.zengularity.querymonad.core
+
+import java.sql.Connection
+
+import scala.language.higherKinds
+
+import cats.{Applicative, Id}
+import cats.data.{Reader, ReaderT}
+
+package object database {
+  type Query[A] = Reader[Connection, A]
+
+  object Query {
+    def pure[A](a: A) = ReaderT.pure[Id, Connection, A](a)
+
+    val ask = ReaderT.ask[Id, Connection]
+
+    def apply[A](f: Connection => A) = new Query(f)
+  }
+
+  type QueryT[F[_], A] = ReaderT[F, Connection, A]
+
+  object QueryT {
+    def pure[M[_]: Applicative, A](a: A) = ReaderT.pure[M, Connection, A](a)
+
+    def ask[M[_]: Applicative] = ReaderT.ask[M, Connection]
+
+    def liftF[M[_], A](ma: M[A]) = ReaderT.liftF[M, Connection, A](ma)
+  }
+
+  type QueryO[A] = QueryT[Option, A]
+
+  type QueryE[A, Err] = QueryT[({ type Res[T] = Either[Err, T] })#Res, A]
+}

core/src/main/scala/core/database/Database.scala

@@ -1,17 +1,16 @@
-package wiring
+package com.zengularity.querymonad.examples.wiring
 
 import scala.concurrent.ExecutionContext
 
 import anorm._
-
 import play.api.ApplicationLoader.Context
 import play.api._
 import play.api.db.{DBComponents, HikariCPComponents}
 import play.api.mvc.Results._
 import play.api.routing.Router
 import play.api.routing.sird._
 
-import database.{Query, QueryRunner}
+import com.zengularity.querymonad.core.database.{Query, QueryRunner}
 
 class AppComponents(context: Context)
     extends BuiltInComponentsFromContext(context)
@@ -21,7 +20,7 @@ class AppComponents(context: Context)
 
   val db = dbApi.database("default")
 
-  def queryRunner(implicit ec: ExecutionContext) = QueryRunner(db, ec)
+  val queryRunner = QueryRunner(db.dataSource, implicitly[ExecutionContext])
 
   val router: Router = Router.from {
 

app/database/QueryRunner.scala renamed to core/src/main/scala/core/database/QueryRunner.scala

@@ -31,7 +31,7 @@ play.i18n.langs = [ "en" ]
 # By convention, the default datasource is named `default`
 
 db.default.driver=org.h2.Driver
-db.default.url="jdbc:h2:mem:play"
+db.default.url="jdbc:h2:mem:play;MODE=PostgreSQL"
 # db.default.username=sa
 # db.default.password=""
 
@@ -43,4 +43,4 @@ db.default.url="jdbc:h2:mem:play"
 # You can disable evolutions for a specific datasource if necessary
 # play.evolutions.db.default.enabled=false
 
-play.application.loader = wiring.AppLoader
+play.application.loader = com.zengularity.querymonad.examples.wiring.AppLoader

core/src/main/scala/core/database/package.scala

@@ -0,0 +1,11 @@
+import sbt._
+
+object Dependencies {
+  lazy val anorm = "org.playframework.anorm" %% "anorm" % "2.6.0"
+
+  lazy val cats = "org.typelevel" %% "cats-core" % "1.0.1"
+
+  lazy val h2 = "com.h2database" % "h2" % "1.4.196"
+
+  lazy val scalaTestPlusPlay = "org.scalatestplus.play" %% "scalatestplus-play" % "3.1.1" % Test
+}