Merge pull request #81 from penland365/issues/80/cats-version-0.9.0

Major dependencies bump, introduce Scala 2.12, remove Scala 2.10.

build.sbt

@@ -1,13 +1,13 @@
 import com.typesafe.sbt.SbtGhPages.GhPagesKeys._
 import sbtunidoc.Plugin.UnidocKeys._
-import ScoverageSbtPlugin._
+//import ScoverageSbtPlugin._
 
 Defaults.itSettings
 
 lazy val buildSettings = Seq(
   organization := "com.github.finagle",
-  scalaVersion := "2.11.8",
-  crossScalaVersions := Seq("2.10.6", "2.11.8")
+  scalaVersion := "2.12.3",
+  crossScalaVersions := Seq("2.11.8", "2.12.3")
 )
 
 lazy val compilerOptions = Seq(
@@ -18,15 +18,14 @@ lazy val compilerOptions = Seq(
   "-Xfatal-warnings",
   "-Xlint",
   "-language:implicitConversions",
-  "-Yinline-warnings",
   "-Yno-adapted-args",
   "-Ywarn-dead-code",
   "-Ywarn-value-discard",
   "-Ypatmat-exhaust-depth", "off",
   "-Xfuture"
 )
 
-lazy val specs2Version = "3.8.5"
+lazy val specs2Version = "3.9.5"
 
 lazy val testDependencies = Seq(
   "org.specs2"      %%  "specs2-core"       %   specs2Version,
@@ -41,16 +40,16 @@ lazy val testDependencies = Seq(
 scalacOptions in Test ++= Seq("-Yrangepos")
 
 lazy val baseSettings = Seq(
-  scalacOptions ++= compilerOptions, 
-  scalacOptions in (Compile, console) := compilerOptions, 
+  scalacOptions ++= compilerOptions,
+  scalacOptions in (Compile, console) := compilerOptions,
   scalacOptions in (Compile, doc) ++= Seq(
     "-doc-title", "roc",
     "-doc-version", version.value,
     "-groups"
   ),
   libraryDependencies ++= testDependencies.map(_ % "it,test"),
   resolvers += Resolver.sonatypeRepo("snapshots"),
-  coverageEnabled := true,
+  //coverageEnabled := true,
   autoAPIMappings := true,
   resolvers += "Twitter Maven repo" at "http://maven.twttr.com/"
 )
@@ -59,15 +58,15 @@ lazy val allSettings = buildSettings ++ baseSettings ++ Defaults.itSettings
 
 lazy val coreVersion = "0.0.5"
 
-lazy val catsVersion = "0.6.0"
+lazy val catsVersion = "0.9.0"
 
-lazy val finagleVersion = "6.38.0"
+lazy val finagleVersion = "6.45.0"
 
-lazy val nettyVersion = "4.1.6.Final"
+lazy val nettyVersion = "4.1.10.Final"
 
-lazy val circeVersion = "0.5.0-M2"
+lazy val circeVersion = "0.8.0"
 
-lazy val jawnVersion = "0.8.4"
+lazy val jawnVersion = "0.10.4"
 
 lazy val roc = project.in(file("."))
   .settings(moduleName := "root")
@@ -86,9 +85,10 @@ lazy val core =  project
   .settings(sharedPublishSettings)
   .settings(
     libraryDependencies ++= Seq(
-      "org.typelevel"   %%  "cats"          %  catsVersion,
-      "io.netty"        %   "netty-buffer"  %  nettyVersion,
-      "com.twitter"     %%  "finagle-core"  %  finagleVersion
+      "org.typelevel"   %%  "cats"            %  catsVersion,
+      "io.netty"        %   "netty-buffer"    %  nettyVersion,
+      "com.twitter"     %%  "finagle-core"    %  finagleVersion
+      //"com.twitter"     %%  "finagle-netty3"  %  finagleVersion
     )
   )
 

core/src/it/scala/roc/Client.scala

@@ -1,13 +1,15 @@
 package roc
 package integrations
 
-import com.twitter.finagle.{Addr, Address, Name, Service}
+import com.twitter.finagle.{Addr, Address, Name}
 import com.twitter.util.Var
 import scala.io.Source
 
 trait Client {
   private val db     = "circle_test"
+  //private val db     = "postgres"
   private val user   = "ubuntu"
+  //private val user   = "postgres"
   private val passwd = ""
   private val host   = "127.0.0.1"
   private val port   = 5432

core/src/it/scala/roc/QuerySpec.scala

@@ -1,12 +1,9 @@
 package roc
 package integrations
 
-import com.twitter.finagle.{Addr, Address, Name, Service}
-import com.twitter.util.Var
 import com.twitter.util.Await
 import org.specs2.Specification
 import roc.postgresql.Request
-import scala.io.Source
 
 final class QuerySpec extends Specification 
   with SqlReader

core/src/main/scala/roc/Postgresql.scala

@@ -1,10 +1,11 @@
 package roc
 
-import com.twitter.finagle.client.{DefaultPool, StackClient, StdStackClient, Transporter}
+import com.twitter.finagle.client.{DefaultPool, StackClient, StdStackClient}
 import com.twitter.finagle.netty3.Netty3Transporter
 import com.twitter.finagle.transport.Transport
 import com.twitter.finagle.{Name, Service, ServiceFactory, Stack}
-import com.twitter.util.{Duration, Future}
+import com.twitter.util.Duration
+import java.net.SocketAddress
 import roc.postgresql.transport.{Packet, PostgresqlClientPipelineFactory}
 import roc.postgresql.{Request, Result, Startup}
 
@@ -61,9 +62,9 @@ object Postgresql extends com.twitter.finagle.Client[Request, Result]
 
   protected type In = Packet
   protected type Out = Packet
-  protected def newTransporter = Netty3Transporter[Packet, Packet](
-    PostgresqlClientPipelineFactory, StackClient.defaultParams)
-  protected def newDispatcher(transport: Transport[Packet, Packet]): 
+  protected def newTransporter(addr: SocketAddress) =
+    Netty3Transporter[Packet, Packet](PostgresqlClientPipelineFactory, addr, StackClient.defaultParams)
+  protected def newDispatcher(transport: Transport[Packet, Packet]):
     Service[Request, Result] = postgresql.ClientDispatcher(transport, Startup(params))
   override def configured[P](psp: (P, Stack.Param[P])): Client = super.configured(psp)
 
@@ -85,7 +86,7 @@ object Postgresql extends com.twitter.finagle.Client[Request, Result]
     */
   val client = Client()
 
-  def newClient(dest: Name, label: String): ServiceFactory[Request, Result] = 
+  def newClient(dest: Name, label: String): ServiceFactory[Request, Result] =
     client.newClient(dest, label)
 
   def newService(dest: Name, label: String): Service[Request, Result] =

core/src/main/scala/roc/postgresql/Client.scala

@@ -17,10 +17,7 @@ trait Client extends Closable {
 final class StdClient(val factory: ServiceFactory[Request, Result]) extends Client {
   private[this] val service = factory.toService
 
-  def query(req: Request): Future[Result] = {
-    val query = new Query(req.query)
-    service(req)
-  }
+  def query(req: Request): Future[Result] = service(req)
 
   def close(deadline: Time): Future[Unit] = service.close(deadline)
 }

core/src/main/scala/roc/postgresql/ClientDispatcher.scala

@@ -1,16 +1,12 @@
 package roc
 package postgresql
 
-import cats.data.Xor
-import cats.std.all._
-import cats.syntax.eq._
 import com.twitter.finagle.dispatch.GenSerialClientDispatcher
 import com.twitter.finagle.transport.Transport
 import com.twitter.finagle.{Service, WriteException}
 import com.twitter.util.{Future, Promise, Time}
 import roc.postgresql.failures.{PostgresqlServerFailure, PostgresqlStateMachineFailure,
   UnsupportedAuthenticationFailure}
-import roc.postgresql.server.{ErrorMessage, PostgresqlMessage, WarningMessage}
 import roc.postgresql.transport.{Packet, PacketEncoder}
 
 private[roc] final class ClientDispatcher(trans: Transport[Packet, Packet],
@@ -55,8 +51,8 @@ private[roc] final class ClientDispatcher(trans: Transport[Packet, Packet],
         for {
           packet <- trans.read()
           message <- Message.decode(packet) match {
-            case Xor.Left(l)  => Future.exception(l)
-            case Xor.Right(m) => Future.value(m)
+            case Left(l)  => Future.exception(l)
+            case Right(m) => Future.value(m)
           }
         } yield message
       }
@@ -73,7 +69,7 @@ private[roc] final class ClientDispatcher(trans: Transport[Packet, Packet],
     for {
       _      <- trans.write(encodePacket(query)).rescue(wrapWriteException)
       signal =  rep.become(readTransport(query, new Promise[Unit]))
-    } yield signal 
+    } yield signal
   }
 
   private[this] def readTransport(req: Transmission, signal: Promise[Unit]): Future[Result] =
@@ -89,23 +85,23 @@ private[roc] final class ClientDispatcher(trans: Transport[Packet, Packet],
     type Collection            = (Descriptions, Rows, CommandCompleteString)
     def go(xs: Descriptions, ys: Rows, ccStr: CommandCompleteString):
       Future[Collection] = trans.read().flatMap(packet => Message.decode(packet) match {
-        case Xor.Right(RowDescription(a,b)) => go(RowDescription(a,b) :: xs, ys, ccStr)
-        case Xor.Right(DataRow(a,b))        => go(xs, DataRow(a,b) :: ys, ccStr)
-        case Xor.Right(EmptyQueryResponse)  => go(xs, ys, "EmptyQueryResponse")
-        case Xor.Right(CommandComplete(x))  => go(xs, ys, x)
-        case Xor.Right(ErrorResponse(e))    => 
+        case Right(RowDescription(a,b)) => go(RowDescription(a,b) :: xs, ys, ccStr)
+        case Right(DataRow(a,b))        => go(xs, DataRow(a,b) :: ys, ccStr)
+        case Right(EmptyQueryResponse)  => go(xs, ys, "EmptyQueryResponse")
+        case Right(CommandComplete(x))  => go(xs, ys, x)
+        case Right(ErrorResponse(e))    =>
           Future.exception(new PostgresqlServerFailure(e))
-        case Xor.Right(NoticeResponse(_))   => go(xs, ys, ccStr) // throw Notice Responses away
-        case Xor.Right(Idle)                => Future.value((xs.reverse, ys.reverse, ccStr))
-        case Xor.Right(u) =>
+        case Right(NoticeResponse(_))   => go(xs, ys, ccStr) // throw Notice Responses away
+        case Right(Idle)                => Future.value((xs.reverse, ys.reverse, ccStr))
+        case Right(u) =>
           Future.exception(new PostgresqlStateMachineFailure("Query", u.toString))
-        case Xor.Left(l)  => Future.exception(l)
+        case Left(l)  => Future.exception(l)
         }
       )
 
     go(List.empty[RowDescription], List.empty[DataRow], "")
       .map(tuple => {
-        val f = signal.setDone()
+        val _ = signal.setDone()
         new Result(tuple._1, tuple._2, tuple._3)
       })
   }
@@ -152,11 +148,11 @@ private[roc] final class ClientDispatcher(trans: Transport[Packet, Packet],
         // TODO - create an Error type for this
         case x if x > 1000 => Future.exception(new Exception())
         case x if x < 1000 => trans.read().flatMap(packet => Message.decode(packet) match {
-          case Xor.Left(l) => Future.exception(l)
-          case Xor.Right(ParameterStatus(i, j)) => go(safetyCheck + 1, ParameterStatus(i,j) :: xs, ys)
-          case Xor.Right(BackendKeyData(i, j)) => go(safetyCheck + 1, xs, BackendKeyData(i, j) :: ys)
-          case Xor.Right(Idle) => Future.value((xs, ys))
-          case Xor.Right(message) => Future.exception(
+          case Left(l) => Future.exception(l)
+          case Right(ParameterStatus(i, j)) => go(safetyCheck + 1, ParameterStatus(i,j) :: xs, ys)
+          case Right(BackendKeyData(i, j)) => go(safetyCheck + 1, xs, BackendKeyData(i, j) :: ys)
+          case Right(Idle) => Future.value((xs, ys))
+          case Right(message) => Future.exception(
             new PostgresqlStateMachineFailure("StartupMessage", message.toString)
           )
         })

core/src/main/scala/roc/postgresql/Messages.scala

@@ -1,18 +1,13 @@
 package roc
 package postgresql
 
-import cats.Eq
-import cats.data.Xor
-import cats.std.all._
-import cats.syntax.eq._
-import com.twitter.util.Future
-import java.nio.charset.StandardCharsets
+import cats.implicits._
+import cats.kernel.Eq
 import java.security.MessageDigest
 import roc.postgresql.failures.{Failure, ReadyForQueryDecodingFailure, UnexpectedNoneFailure,
   UnknownAuthenticationRequestFailure, UnknownPostgresqlMessageTypeFailure}
 import roc.postgresql.server.PostgresqlMessage
-import roc.postgresql.transport.{Buffer, BufferReader, BufferWriter, Packet}
-import scala.collection.mutable.ListBuffer
+import roc.postgresql.transport.Packet
 
 private[postgresql] sealed abstract class Message
 private[postgresql] object Message {
@@ -30,7 +25,7 @@ private[postgresql] object Message {
   val TerminateByte: Char             = 'X'
   val NoticeResponseByte: Char        = 'N'
 
-  private[postgresql] def decode(packet: Packet): Xor[Failure, Message] = packet.messageType match {
+  private[postgresql] def decode(packet: Packet): Either[Failure, Message] = packet.messageType match {
     case Some(mt) if mt === AuthenticationMessageByte => decodePacket[AuthenticationMessage](packet)
     case Some(mt) if mt === ErrorByte => decodePacket[ErrorResponse](packet)
     case Some(mt) if mt === NoticeResponseByte => decodePacket[NoticeResponse](packet)
@@ -40,12 +35,9 @@ private[postgresql] object Message {
     case Some(mt) if mt === RowDescriptionByte => decodePacket[RowDescription](packet)
     case Some(mt) if mt === DataRowByte => decodePacket[DataRow](packet)
     case Some(mt) if mt === CommandCompleteByte => decodePacket[CommandComplete](packet)
-    case Some(mt) if mt === EmptyQueryResponseByte => Xor.Right(EmptyQueryResponse)
-    case Some(mt) => {
-        println(s"Inside Some($mt)")
-        Xor.Left(new UnknownPostgresqlMessageTypeFailure(mt))
-    }
-    case None => Xor.Left(new UnexpectedNoneFailure(""))
+    case Some(mt) if mt === EmptyQueryResponseByte => Right(EmptyQueryResponse)
+    case Some(mt) => Left(new UnknownPostgresqlMessageTypeFailure(mt))
+    case None => Left(new UnexpectedNoneFailure(""))
   }
 
   implicit val messageEq: Eq[Message] = new Eq[Message] {
@@ -81,21 +73,21 @@ private[postgresql] case class ErrorResponse(error: PostgresqlMessage) extends B
 
 private[postgresql] sealed abstract class AuthenticationMessage extends BackendMessage
 private[postgresql] object AuthenticationMessage {
-  def apply(tuple: (Int, Option[Array[Byte]])): Failure Xor AuthenticationMessage = tuple match {
-    case (0, None)        => Xor.Right(AuthenticationOk)
-    case (2, None)        => Xor.Right(AuthenticationKerberosV5)
-    case (3, None)        => Xor.Right(AuthenticationClearTxtPasswd)
-    case (5, Some(bytes)) => Xor.Right(new AuthenticationMD5Passwd(bytes))
-    case (6, None)        => Xor.Right(AuthenticationSCMCredential)
-    case (7, None)        => Xor.Right(AuthenticationGSS)
-    case (8, Some(bytes)) => Xor.Right(new AuthenticationGSSContinue(bytes))
-    case (9, None)        => Xor.Right(AuthenticationSSPI)
-    case (x, _)           => Xor.Left(new UnknownAuthenticationRequestFailure(x))
+  def apply(tuple: (Int, Option[Array[Byte]])): Failure Either AuthenticationMessage = tuple match {
+    case (0, None)        => Right(AuthenticationOk)
+    case (2, None)        => Right(AuthenticationKerberosV5)
+    case (3, None)        => Right(AuthenticationClearTxtPasswd)
+    case (5, Some(bytes)) => Right(new AuthenticationMD5Passwd(bytes))
+    case (6, None)        => Right(AuthenticationSCMCredential)
+    case (7, None)        => Right(AuthenticationGSS)
+    case (8, Some(bytes)) => Right(new AuthenticationGSSContinue(bytes))
+    case (9, None)        => Right(AuthenticationSSPI)
+    case (x, _)           => Left(new UnknownAuthenticationRequestFailure(x))
   }
 }
 private[postgresql] case object AuthenticationOk extends AuthenticationMessage
 private[postgresql] case object AuthenticationClearTxtPasswd extends AuthenticationMessage
-private[postgresql] case class AuthenticationMD5Passwd(salt: Array[Byte]) 
+private[postgresql] case class AuthenticationMD5Passwd(salt: Array[Byte])
   extends AuthenticationMessage {
   def canEqual(a: Any) = a.isInstanceOf[AuthenticationMD5Passwd]
 
@@ -128,12 +120,12 @@ private[postgresql] case class BackendKeyData(processId: Int, secretKey: Int) ex
 
 private[postgresql] sealed abstract class ReadyForQuery extends BackendMessage
 private[postgresql] object ReadyForQuery {
-  def apply(transactionStatus: Char): ReadyForQueryDecodingFailure Xor ReadyForQuery = 
+  def apply(transactionStatus: Char): ReadyForQueryDecodingFailure Either ReadyForQuery = 
     transactionStatus match {
-      case 'I' => Xor.Right(Idle)
-      case 'T' => Xor.Right(TransactionBlock)
-      case 'E' => Xor.Right(FailedTransactionBlock)
-      case  c  => Xor.Left(new ReadyForQueryDecodingFailure(c))
+      case 'I' => Right(Idle)
+      case 'T' => Right(TransactionBlock)
+      case 'E' => Right(FailedTransactionBlock)
+      case  c  => Left(new ReadyForQueryDecodingFailure(c))
     }
 }
 

core/src/main/scala/roc/postgresql/failures.scala

@@ -2,7 +2,6 @@ package roc
 package postgresql
 
 import cats.data.NonEmptyList
-import cats.implicits._
 import roc.postgresql.server.PostgresqlMessage
 
 object failures {