Use a common implementation for JSON repositories

The purpose of this PR is to remove duplicated code. It should also make it
easier to improve or replace concrete repository implementations later.

Author: fthomas

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

@@ -16,68 +16,51 @@
 
 package org.scalasteward.core.nurture.json
 
-import better.files.File
 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, MonadThrowable}
 import org.scalasteward.core.vcs.data.{PullRequestState, Repo}
 
-class JsonPullRequestRepo[F[_]](
+final class JsonPullRequestRepo[F[_]](
     implicit
     fileAlg: FileAlg[F],
     workspaceAlg: WorkspaceAlg[F],
     F: MonadThrowable[F]
 ) extends PullRequestRepository[F] {
+  private val kvStore = new JsonKeyValueStore[F, Repo, Map[String, PullRequestData]]("prs", "3")
+
   override def createOrUpdate(
       repo: Repo,
       url: Uri,
       baseSha1: Sha1,
       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,14 +16,11 @@
 
 package org.scalasteward.core.repocache.json
 
-import better.files.File
 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, MonadThrowable}
 import org.scalasteward.core.vcs.data.Repo
 
 final class JsonRepoCacheRepository[F[_]](
@@ -32,30 +29,16 @@ final class JsonRepoCacheRepository[F[_]](
     workspaceAlg: WorkspaceAlg[F],
     F: MonadThrowable[F]
 ) extends RepoCacheRepository[F] {
+  private val kvStore = new JsonKeyValueStore[F, Repo, RepoCache]("repos", "6")
+
   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,27 @@
 
 package org.scalasteward.core.update.json
 
-import better.files.File
 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, MonadThrowable}
 
-// WIP
-class JsonUpdateRepository[F[_]](
+final class JsonUpdateRepository[F[_]](
     implicit
     fileAlg: FileAlg[F],
     workspaceAlg: WorkspaceAlg[F],
     F: MonadThrowable[F]
 ) extends UpdateRepository[F] {
+  private val kvStore = new JsonKeyValueStore[F, String, List[Update.Single]]("updates", "3")
+  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,56 @@
+/*
+ * 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 jsonFile: F[File] =
+    workspaceAlg.rootDir.map(_ / s"${name}_v${schemaVersion}.json")
+
+  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))
+}