BREAKING CHANGE: use simple cache instead of scala-cache

Author: ldip

build.sbt

@@ -1,25 +1,21 @@
 import CompileFlags._
-import sbt.Keys.crossScalaVersions
 import DependenciesScopesHandler._
 import Dependencies._
 import PublishSettings.localCacheSettings
 import org.typelevel.scalacoptions.ScalacOptions
 
-lazy val scala212               = "2.12.13"
-lazy val scala213               = "2.13.11"
-lazy val supportedScalaVersions = List(scala213, scala212)
+lazy val scala213 = "2.13.11"
 
 Global / onChangedBuildSource := ReloadOnSourceChanges
 
 inThisBuild {
   List(
-    organization       := "com.colisweb",
-    scalaVersion       := scala213,
-    crossScalaVersions := supportedScalaVersions,
-    scalafmtOnCompile  := true,
-    scalafmtCheck      := true,
-    scalafmtSbtCheck   := true,
-    Test / fork        := true,
+    organization      := "com.colisweb",
+    scalaVersion      := scala213,
+    scalafmtOnCompile := true,
+    scalafmtCheck     := true,
+    scalafmtSbtCheck  := true,
+    Test / fork       := true,
     scalacOptions ++= crossScalacOptions(scalaVersion.value),
     localCacheSettings
   )
@@ -29,20 +25,20 @@ inThisBuild {
 lazy val root = Project(id = "scala-distances", base = file("."))
   .settings(moduleName := "root")
   .settings(noPublishSettings)
-  .aggregate(core, `google-provider`, `here-provider`, `redis-cache`, `caffeine-cache`, tests)
-  .dependsOn(core, `google-provider`, `here-provider`, `redis-cache`, `caffeine-cache`, tests)
+  .aggregate(core, `google-provider`, `here-provider`, tests)
+  .dependsOn(core, `google-provider`, `here-provider`, tests)
 
 lazy val core = project
   .settings(moduleName := "scala-distances-core")
   .settings(Test / tpolecatExcludeOptions += ScalacOptions.warnNonUnitStatement)
-  .settings(libraryDependencies ++= compileDependencies(cats, scalaCache, squants))
+  .settings(libraryDependencies ++= compileDependencies(squants, simplecacheWrapperCats))
   .settings(
     libraryDependencies ++= testDependencies(
-      monix,
       mockitoScalaScalatest,
       scalacheck,
       scalatest,
-      scalatestPlus
+      scalatestPlus,
+      simplecacheMemory
     )
   )
 
@@ -52,7 +48,7 @@ lazy val `google-provider` = project
   .in(file("providers/google"))
   .settings(moduleName := "scala-distances-provider-google")
   .settings(
-    libraryDependencies ++= compileDependencies(catsEffect, enumeratum, googleMaps, loggingInterceptor, refined)
+    libraryDependencies ++= compileDependencies(enumeratum, googleMaps, loggingInterceptor, refined)
   )
   .dependsOn(core)
 
@@ -61,15 +57,13 @@ lazy val `here-provider` = project
   .settings(moduleName := "scala-distances-provider-here")
   .settings(
     libraryDependencies ++= compileDependencies(
-      catsEffect,
       circe,
       circeGeneric,
       circeGenericExtras,
       circeJawn,
       logstashLogbackEncode,
       refined,
-      requests,
-      scalaCompat
+      requests
     )
   )
   .dependsOn(core)
@@ -79,22 +73,22 @@ lazy val `here-provider` = project
 lazy val `redis-cache` = project
   .in(file("caches/redis"))
   .settings(moduleName := "scala-distances-cache-redis")
-  .settings(libraryDependencies ++= compileDependencies(scalaCacheRedis))
+  .settings(libraryDependencies ++= compileDependencies(simplecacheRedisCirce))
   .dependsOn(core)
 
-lazy val `caffeine-cache` = project
-  .in(file("caches/caffeine"))
-  .settings(moduleName := "scala-distances-cache-caffeine")
-  .settings(libraryDependencies ++= compileDependencies(scalaCacheCaffeine))
+lazy val `memory-guava` = project
+  .in(file("caches/memory-guava"))
+  .settings(moduleName := "scala-distances-memory-guava")
+  .settings(libraryDependencies ++= compileDependencies(simplecacheMemoryGuava))
   .dependsOn(core)
 
 //// Meta projects
 
 lazy val tests = project
   .settings(noPublishSettings)
   .settings(Test / tpolecatExcludeOptions += ScalacOptions.warnNonUnitStatement)
-  .dependsOn(core % "test->test;compile->compile", `google-provider`, `here-provider`, `redis-cache`, `caffeine-cache`)
-  .settings(libraryDependencies ++= testDependencies(pureconfig, refinedPureconfig, scalaCacheCatsEffect, approvals))
+  .dependsOn(core % "test->test;compile->compile", `google-provider`, `here-provider`, `redis-cache`, `memory-guava`)
+  .settings(libraryDependencies ++= testDependencies(pureconfig, refinedPureconfig, simplecacheRedisCirce, approvals))
 
 /** Copied from Cats */
 lazy val noPublishSettings = Seq(

caches/caffeine/src/main/scala/com/colisweb/distances/caches/CaffeineCache.scala

@@ -0,0 +1,13 @@
+package com.colisweb.distances.caches
+
+import cats.effect.Sync
+import com.colisweb.simplecache.memory.guava.GuavaCache
+import com.colisweb.simplecache.wrapper.cats.CatsCache
+
+import scala.concurrent.duration.FiniteDuration
+
+object CatsGuavaCache {
+
+  def apply[F[_]: Sync, K, V](ttl: Option[FiniteDuration]): CatsCache[F, K, V] =
+    CatsCache(new GuavaCache[K, V](ttl))
+}

caches/memory-guava/src/main/scala/com/colisweb/distances/caches/CatsGuavaCache.scala

@@ -0,0 +1,20 @@
+package com.colisweb.distances.caches
+
+import cats.effect.Sync
+import com.colisweb.simplecache.redis.RedisConfiguration
+import com.colisweb.simplecache.redis.RedisConfiguration.pool
+import com.colisweb.simplecache.redis.codec._
+import com.colisweb.simplecache.redis.circe.RedisCirceCache
+import com.colisweb.simplecache.wrapper.cats.CatsCache
+
+import scala.concurrent.duration.FiniteDuration
+
+object CatsRedisCache {
+
+  def apply[F[_]: Sync, K, V](
+      configuration: RedisConfiguration,
+      ttl: Option[FiniteDuration],
+      keyEncoder: Encoder[K] = AnyEncoder()
+  )(implicit codec: io.circe.Codec[V]): CatsCache[F, K, V] =
+    CatsCache(new RedisCirceCache[K, V](pool(configuration), ttl)(keyEncoder, codec))
+}

caches/redis/src/main/scala/com/colisweb/distances/caches/CatsRedisCache.scala

@@ -1,10 +1,12 @@
 package com.colisweb.distances
 
+import cats.effect.Sync
 import cats.{Applicative, MonadError}
 import com.colisweb.distances.bird.HaversineDistanceApi
-import com.colisweb.distances.cache.{Cache, DistanceFromCache, DistanceWithCache}
+import com.colisweb.distances.cache.{DistanceFromCache, DistanceWithCache}
 import com.colisweb.distances.correction.CorrectPastDepartureTime
 import com.colisweb.distances.model._
+import com.colisweb.simplecache.wrapper.cats.CatsCache
 
 import java.time.Clock
 import scala.concurrent.duration.FiniteDuration
@@ -27,7 +29,7 @@ case class Distances[F[_], P](api: DistanceApi[F, P]) {
   )(when: PartialFunction[Throwable, F[Unit]])(implicit F: MonadError[F, Throwable]): Distances[F, P] =
     copy(api = Fallback(api, other.api, when))
 
-  def caching(cache: Cache[F, P, PathResult])(implicit F: MonadError[F, Throwable]): Distances[F, P] =
+  def caching(cache: CatsCache[F, P, PathResult])(implicit F: Sync[F]): Distances[F, P] =
     copy(api = DistanceWithCache(cache, api))
 
   def correctPastDepartureTime(
@@ -44,7 +46,7 @@ object Distances {
 
   implicit def from[F[_], P](api: DistanceApi[F, P]): Distances[F, P] = Distances(api)
 
-  implicit def fromCache[F[_], P](cache: Cache[F, P, PathResult])(implicit
+  implicit def fromCache[F[_], P](cache: CatsCache[F, P, PathResult])(implicit
       F: MonadError[F, Throwable]
   ): Distances[F, P] =
     from(DistanceFromCache(cache))

caches/redis/src/main/scala/com/colisweb/distances/caches/RedisCache.scala

@@ -1,15 +1,16 @@
 package com.colisweb.distances.cache
 
 import cats.MonadError
+import cats.effect.Sync
 import cats.implicits._
 import com.colisweb.distances.DistanceApi
 import com.colisweb.distances.model.PathResult
-import org.slf4j.{Logger, LoggerFactory}
+import com.colisweb.simplecache.wrapper.cats._
 
 import scala.util.control.NoStackTrace
 
 case class DistanceFromCache[F[_], P](
-    cache: Cache[F, P, PathResult]
+    cache: CatsCache[F, P, PathResult]
 )(implicit F: MonadError[F, Throwable])
     extends DistanceApi[F, P] {
 
@@ -22,29 +23,10 @@ case class DistanceFromCache[F[_], P](
 
 final case class CacheMissError(key: Any) extends RuntimeException(s"No entry in cache for $key") with NoStackTrace
 
-case class DistanceWithCache[F[_], P](
-    cache: Cache[F, P, PathResult],
+case class DistanceWithCache[F[_]: Sync, P](
+    cache: CatsCache[F, P, PathResult],
     api: DistanceApi[F, P]
-)(implicit F: MonadError[F, Throwable])
-    extends DistanceApi[F, P] {
-  private lazy val logger: Logger = LoggerFactory.getLogger(getClass)
-  override def distance(path: P): F[PathResult] = {
-    cache.get(path).attempt.flatMap {
-      case Right(Some(distance)) => F.pure(distance)
-      case Right(None)           => computeAndCacheDistance(path)
-      case Left(error) =>
-        F.pure(logger.warn(s"Fail to get distance from cache for $path", error)) *>
-          computeAndCacheDistance(path)
-    }
-  }
+) extends DistanceApi[F, P] {
+  override def distance(path: P): F[PathResult] = cache.getOrElseUpdate(path, api.distance(path))
 
-  private def computeAndCacheDistance(path: P): F[PathResult] = {
-    api
-      .distance(path)
-      .flatTap(
-        cache
-          .put(path, _)
-          .handleError(logger.warn(s"Fail to get distance from cache for $path", _))
-      )
-  }
 }

caches/redis/src/main/scala/com/colisweb/distances/caches/RedisConfiguration.scala

@@ -1,34 +1,36 @@
 package com.colisweb.distances.cache
 
+import cats.effect.IO
 import com.colisweb.distances.Distances
 import com.colisweb.distances.model.path.DirectedPath
 import com.colisweb.distances.model.{PathResult, Point}
 import com.colisweb.distances.util.FromMapDistances
+import com.colisweb.simplecache.memory.MemoryCache
+import com.colisweb.simplecache.wrapper.cats.CatsCache
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.wordspec.AnyWordSpec
 
-import scala.util.{Failure, Try}
-
 class CacheSpec extends AnyWordSpec with Matchers {
 
-  private val failingCache: Cache[Try, DirectedPath, PathResult] =
-    new Cache[Try, DirectedPath, PathResult] {
-      private val failure: Failure[Nothing]                            = Failure(new RuntimeException("failure"))
-      override def get(key: DirectedPath): Try[Option[PathResult]]     = failure
-      override def put(key: DirectedPath, value: PathResult): Try[Any] = failure
+  private val failingCache: CatsCache[IO, DirectedPath, PathResult] = {
+    new CatsCache[IO, DirectedPath, PathResult](new MemoryCache()) {
+      private val failure: IO[Nothing]                            = IO.raiseError(new RuntimeException("failure"))
+      override def get(key: DirectedPath): IO[Option[PathResult]] = failure
+      override def update(key: DirectedPath, value: PathResult): IO[Unit] = failure
     }
+  }
 
   private val path: DirectedPath     = DirectedPath(Point(0, 0), Point(0, 0))
   private val pathResult: PathResult = PathResult(1, 1)
 
-  private val distanceMap: Distances[Try, DirectedPath] =
-    FromMapDistances[Try]
+  private val distanceMap: Distances[IO, DirectedPath] =
+    FromMapDistances[IO]
       .fromMap(Map(path -> pathResult))
       .caching(failingCache)
 
   "Failing cache" should {
     "not propagate failure on caching" in {
-      distanceMap.api.distance(path).get shouldBe pathResult
+      distanceMap.api.distance(path).unsafeRunSync() shouldBe pathResult
     }
   }
 }