Merge pull request #945 from fthomas/topic/kv-store

Use a common implementation for JSON repositories

Author: fthomas

modules/core/src/main/scala/org/scalasteward/core/application/Context.scala

@@ -34,7 +34,7 @@ import org.scalasteward.core.sbt.SbtAlg
 import org.scalasteward.core.scalafmt.ScalafmtAlg
 import org.scalasteward.core.update.json.JsonUpdateRepository
 import org.scalasteward.core.update.{FilterAlg, UpdateRepository, UpdateService}
-import org.scalasteward.core.util.{DateTimeAlg, HttpExistenceClient, HttpJsonClient}
+import org.scalasteward.core.util._
 import org.scalasteward.core.vcs.data.AuthenticatedUser
 import org.scalasteward.core.vcs.{VCSApiAlg, VCSExtraAlg, VCSRepoAlg, VCSSelection}
 
@@ -58,17 +58,20 @@ object Context {
       implicit val gitAlg: GitAlg[F] = GitAlg.create[F]
       implicit val httpJsonClient: HttpJsonClient[F] = new HttpJsonClient[F]
       implicit val httpExistenceClient: HttpExistenceClient[F] = new HttpExistenceClient[F]
-      implicit val repoCacheRepository: RepoCacheRepository[F] = new JsonRepoCacheRepository[F]
+      implicit val repoCacheRepository: RepoCacheRepository[F] =
+        new JsonRepoCacheRepository[F](new JsonKeyValueStore("repos", "6"))
       val vcsSelection = new VCSSelection[F]
       implicit val vcsApiAlg: VCSApiAlg[F] = vcsSelection.getAlg(config)
       implicit val vcsRepoAlg: VCSRepoAlg[F] = VCSRepoAlg.create[F](config, gitAlg)
       implicit val vcsExtraAlg: VCSExtraAlg[F] = VCSExtraAlg.create[F]
-      implicit val pullRequestRepo: PullRequestRepository[F] = new JsonPullRequestRepo[F]
+      implicit val pullRequestRepo: PullRequestRepository[F] =
+        new JsonPullRequestRepo[F](new JsonKeyValueStore("prs", "3"))
       implicit val scalafmtAlg: ScalafmtAlg[F] = ScalafmtAlg.create[F]
       implicit val sbtAlg: SbtAlg[F] = SbtAlg.create[F]
       implicit val repoCacheAlg: RepoCacheAlg[F] = new RepoCacheAlg[F]
       implicit val editAlg: EditAlg[F] = new EditAlg[F]
-      implicit val updateRepository: UpdateRepository[F] = new JsonUpdateRepository[F]
+      implicit val updateRepository: UpdateRepository[F] =
+        new JsonUpdateRepository[F](new JsonKeyValueStore("updates", "3"))
       implicit val coursierAlg: CoursierAlg[F] = CoursierAlg.create
       implicit val nurtureAlg: NurtureAlg[F] = new NurtureAlg[F]
       implicit val updateService: UpdateService[F] = new UpdateService[F]

modules/core/src/main/scala/org/scalasteward/core/nurture/json/JsonPullRequestRepo.scala

@@ -16,24 +16,18 @@
 
 package org.scalasteward.core.nurture.json
 
-import better.files.File
+import cats.FlatMap
 import cats.implicits._
-import io.circe.parser.decode
-import io.circe.syntax._
 import org.http4s.Uri
 import org.scalasteward.core.data.{Dependency, Update}
 import org.scalasteward.core.git.Sha1
-import org.scalasteward.core.io.{FileAlg, WorkspaceAlg}
 import org.scalasteward.core.nurture.PullRequestRepository
 import org.scalasteward.core.update.UpdateService
-import org.scalasteward.core.util.MonadThrowable
+import org.scalasteward.core.util.JsonKeyValueStore
 import org.scalasteward.core.vcs.data.{PullRequestState, Repo}
 
-class JsonPullRequestRepo[F[_]](
-    implicit
-    fileAlg: FileAlg[F],
-    workspaceAlg: WorkspaceAlg[F],
-    F: MonadThrowable[F]
+final class JsonPullRequestRepo[F[_]: FlatMap](
+    kvStore: JsonKeyValueStore[F, Repo, Map[String, PullRequestData]]
 ) extends PullRequestRepository[F] {
   override def createOrUpdate(
       repo: Repo,
@@ -42,42 +36,26 @@ class JsonPullRequestRepo[F[_]](
       update: Update,
       state: PullRequestState
   ): F[Unit] =
-    readJson.flatMap { store =>
-      val updated = store.store.get(repo) match {
+    kvStore.read.flatMap { store =>
+      val updated = store.get(repo) match {
         case Some(prs) => prs.updated(url.toString(), PullRequestData(baseSha1, update, state))
         case None      => Map(url.toString() -> PullRequestData(baseSha1, update, state))
       }
-      writeJson(PullRequestStore(store.store.updated(repo, updated)))
+      kvStore.write(store.updated(repo, updated))
     }
 
   override def findPullRequest(
       repo: Repo,
       dependency: Dependency,
       newVersion: String
   ): F[Option[(Uri, Sha1, PullRequestState)]] =
-    readJson.map { store =>
-      val pullRequests = store.store.get(repo).fold(List.empty[(String, PullRequestData)])(_.toList)
+    kvStore.read.map { store =>
+      val pullRequests = store.get(repo).fold(List.empty[(String, PullRequestData)])(_.toList)
       pullRequests
         .find {
           case (_, data) =>
             UpdateService.isUpdateFor(data.update, dependency) && data.update.nextVersion === newVersion
         }
         .map { case (url, data) => (Uri.unsafeFromString(url), data.baseSha1, data.state) }
     }
-
-  def jsonFile: F[File] =
-    workspaceAlg.rootDir.map(_ / "prs_v02.json")
-
-  def readJson: F[PullRequestStore] =
-    jsonFile.flatMap { file =>
-      fileAlg.readFile(file).flatMap {
-        case Some(content) => F.fromEither(decode[PullRequestStore](content))
-        case None          => F.pure(PullRequestStore(Map.empty))
-      }
-    }
-
-  def writeJson(store: PullRequestStore): F[Unit] =
-    jsonFile.flatMap { file =>
-      fileAlg.writeFile(file, store.asJson.toString)
-    }
 }

modules/core/src/main/scala/org/scalasteward/core/nurture/json/PullRequestStore.scala

@@ -16,46 +16,24 @@
 
 package org.scalasteward.core.repocache.json
 
-import better.files.File
+import cats.Functor
 import cats.implicits._
-import io.circe.parser.decode
-import io.circe.syntax._
 import org.scalasteward.core.data.Dependency
-import org.scalasteward.core.io.{FileAlg, WorkspaceAlg}
 import org.scalasteward.core.repocache.{RepoCache, RepoCacheRepository}
-import org.scalasteward.core.util.MonadThrowable
+import org.scalasteward.core.util.JsonKeyValueStore
 import org.scalasteward.core.vcs.data.Repo
 
-final class JsonRepoCacheRepository[F[_]](
-    implicit
-    fileAlg: FileAlg[F],
-    workspaceAlg: WorkspaceAlg[F],
-    F: MonadThrowable[F]
+final class JsonRepoCacheRepository[F[_]: Functor](
+    kvStore: JsonKeyValueStore[F, Repo, RepoCache]
 ) extends RepoCacheRepository[F] {
   override def findCache(repo: Repo): F[Option[RepoCache]] =
-    readJson.map(_.store.get(repo))
+    kvStore.get(repo)
 
   override def updateCache(repo: Repo, repoCache: RepoCache): F[Unit] =
-    readJson.flatMap { store =>
-      writeJson(RepoStore(store.store.updated(repo, repoCache)))
-    }
+    kvStore.put(repo, repoCache)
 
   override def getDependencies(repos: List[Repo]): F[List[Dependency]] =
-    readJson.map(_.store.filterKeys(repos.contains).values.flatMap(_.dependencies).toList.distinct)
-
-  def jsonFile: F[File] =
-    workspaceAlg.rootDir.map(_ / "repos_v05.json")
-
-  def readJson: F[RepoStore] =
-    jsonFile.flatMap { file =>
-      fileAlg.readFile(file).flatMap {
-        case Some(content) => F.fromEither(decode[RepoStore](content))
-        case None          => F.pure(RepoStore(Map.empty))
-      }
-    }
-
-  def writeJson(store: RepoStore): F[Unit] =
-    jsonFile.flatMap { file =>
-      fileAlg.writeFile(file, store.asJson.toString)
+    kvStore.read.map {
+      _.filterKeys(repos.contains).values.flatMap(_.dependencies).toList.distinct
     }
 }

modules/core/src/main/scala/org/scalasteward/core/repocache/json/JsonRepoCacheRepository.scala

@@ -16,42 +16,23 @@
 
 package org.scalasteward.core.update.json
 
-import better.files.File
+import cats.FlatMap
 import cats.implicits._
-import io.circe.parser.decode
-import io.circe.syntax._
 import org.scalasteward.core.data.Update
-import org.scalasteward.core.io.{FileAlg, WorkspaceAlg}
 import org.scalasteward.core.update.UpdateRepository
-import org.scalasteward.core.util.MonadThrowable
+import org.scalasteward.core.util.JsonKeyValueStore
 
-// WIP
-class JsonUpdateRepository[F[_]](
-    implicit
-    fileAlg: FileAlg[F],
-    workspaceAlg: WorkspaceAlg[F],
-    F: MonadThrowable[F]
+final class JsonUpdateRepository[F[_]: FlatMap](
+    kvStore: JsonKeyValueStore[F, String, List[Update.Single]]
 ) extends UpdateRepository[F] {
+  private val key = "updates"
 
   override def deleteAll: F[Unit] =
-    writeJson(UpdateStore(Set.empty))
+    kvStore.write(Map.empty)
 
   override def saveMany(updates: List[Update.Single]): F[Unit] =
-    readJson.map(s => UpdateStore(s.store ++ updates)).flatMap(writeJson)
-
-  def jsonFile: F[File] =
-    workspaceAlg.rootDir.map(_ / "updates_v02.json")
-
-  def readJson: F[UpdateStore] =
-    jsonFile.flatMap { file =>
-      fileAlg.readFile(file).flatMap {
-        case Some(content) => F.fromEither(decode[UpdateStore](content))
-        case None          => F.pure(UpdateStore(Set.empty))
-      }
-    }
-
-  def writeJson(store: UpdateStore): F[Unit] =
-    jsonFile.flatMap { file =>
-      fileAlg.writeFile(file, store.asJson.toString)
-    }
+    kvStore
+      .getOrElse(key, List.empty)
+      .map(_ ++ updates)
+      .flatMap(list => kvStore.write(Map(key -> list)))
 }

modules/core/src/main/scala/org/scalasteward/core/repocache/json/RepoStore.scala

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2018-2019 Scala Steward contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.scalasteward.core.util
+
+import better.files.File
+import cats.implicits._
+import io.circe.parser.decode
+import io.circe.syntax._
+import io.circe.{Decoder, Encoder, KeyDecoder, KeyEncoder}
+import org.scalasteward.core.io.{FileAlg, WorkspaceAlg}
+
+final class JsonKeyValueStore[F[_], K, V](name: String, schemaVersion: String)(
+    implicit
+    fileAlg: FileAlg[F],
+    workspaceAlg: WorkspaceAlg[F],
+    F: MonadThrowable[F],
+    keyDecoder: KeyDecoder[K],
+    keyEncoder: KeyEncoder[K],
+    valueDecoder: Decoder[V],
+    valueEncoder: Encoder[V]
+) {
+  private val filename =
+    s"${name}_v${schemaVersion}.json"
+
+  private val jsonFile: F[File] =
+    workspaceAlg.rootDir.map(_ / filename)
+
+  def get(key: K): F[Option[V]] =
+    read.map(_.get(key))
+
+  def getOrElse(key: K, default: => V): F[V] =
+    get(key).map(_.getOrElse(default))
+
+  def put(key: K, value: V): F[Unit] =
+    read.map(_.updated(key, value)).flatMap(write)
+
+  def read: F[Map[K, V]] =
+    jsonFile.flatMap(fileAlg.readFile).flatMap {
+      case Some(content) => F.fromEither(decode[Map[K, V]](content))
+      case None          => F.pure(Map.empty[K, V])
+    }
+
+  def write(store: Map[K, V]): F[Unit] =
+    jsonFile.flatMap(fileAlg.writeFile(_, store.asJson.toString))
+}

modules/core/src/main/scala/org/scalasteward/core/update/json/JsonUpdateRepository.scala

@@ -15,7 +15,7 @@ import org.scalasteward.core.repoconfig.RepoConfigAlg
 import org.scalasteward.core.sbt.SbtAlg
 import org.scalasteward.core.scalafmt.ScalafmtAlg
 import org.scalasteward.core.update.FilterAlg
-import org.scalasteward.core.util.{BracketThrowable, DateTimeAlg}
+import org.scalasteward.core.util.{BracketThrowable, DateTimeAlg, JsonKeyValueStore}
 import org.scalasteward.core.vcs.VCSRepoAlg
 import org.scalasteward.core.vcs.data.AuthenticatedUser
 import scala.concurrent.duration._
@@ -58,7 +58,7 @@ object MockContext {
   implicit val gitHubRepoAlg: VCSRepoAlg[MockEff] = VCSRepoAlg.create(config, gitAlg)
   implicit val scalafmtAlg: ScalafmtAlg[MockEff] = ScalafmtAlg.create
   implicit val cacheRepository: RepoCacheRepository[MockEff] =
-    new JsonRepoCacheRepository[MockEff]()
+    new JsonRepoCacheRepository[MockEff](new JsonKeyValueStore("repos", "6"))
   implicit val sbtAlg: SbtAlg[MockEff] = SbtAlg.create
   implicit val editAlg: EditAlg[MockEff] = new EditAlg[MockEff]
   implicit val repoConfigAlg: RepoConfigAlg[MockEff] = new RepoConfigAlg[MockEff]