Update and modernize

Author: dacr

.gitignore

@@ -13,3 +13,4 @@ test*.log
 static-examples/
 lmdb-examples/
 .scala-build/
+test.sh

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 3.7.3
+version = 3.8.3
 runner.dialect = scala3
 align.preset = most
 maxColumn = 250

build.sbt

@@ -1,21 +1,21 @@
 name        := "zwords"
 description := "Guess a word everyday game"
-scalaVersion := "3.2.2"
+scalaVersion := "3.5.1"
 
 val versions = new {
-  val zio        = "2.0.13"
-  val zionio     = "2.0.1"
-  val zioconfig  = "3.0.7"
+  val zio        = "2.1.9"
+  val zionio     = "2.0.2"
+  val zioconfig  = "4.0.2"
   val ziocli     = "0.2.2"
-  val ziojson    = "0.5.0"
-  val ziologging = "2.1.12"
-  val ziolmdb    = "1.0.6"
-  val tapir      = "1.2.13"
-  val logback    = "1.4.7"
+  val ziojson    = "0.7.3"
+  val ziologging = "2.3.1"
+  val ziolmdb    = "1.8.2"
+  val tapir      = "1.11.5"
+  val logback    = "1.5.8"
 }
 
 val sharedSettings = Seq(
-  scalaVersion := "3.2.2",
+  scalaVersion := "3.5.1",
   Test / fork  := true,
   testFrameworks += new TestFramework("zio.test.sbt.ZTestFramework"),
   scalacOptions ++= Seq("-deprecation"), // "-Xfatal-warnings",

console/src/main/scala/fr/janalyse/zwords/console/Main.scala

@@ -1,15 +1,26 @@
 package fr.janalyse.zwords.console
 
+import com.typesafe.config.ConfigFactory
 import fr.janalyse.zwords.gamelogic.{Game, GameInternalIssue, GameIssue, GoodPlaceCell}
 import fr.janalyse.zwords.dictionary.DictionaryService
 import fr.janalyse.zwords.dictionary.DictionaryConfig
 import fr.janalyse.zwords.wordgen.{WordGeneratorLanguageNotSupported, WordGeneratorService}
 import zio.*
+import zio.Runtime.removeDefaultLoggers
+import zio.config.typesafe.TypesafeConfigProvider
 
 import scala.Console.{RED, RESET, YELLOW}
 import java.io.IOException
 
 object Main extends ZIOAppDefault {
+  override val bootstrap: ZLayer[ZIOAppArgs, Any, Any] = {
+    val configProviderLayer = {
+      val config   = ConfigFactory.load()
+      val provider = TypesafeConfigProvider.fromTypesafeConfig(config).kebabCase
+      Runtime.setConfigProvider(provider)
+    }
+    configProviderLayer
+  }
 
   def playLogic(game: Game): ZIO[WordGeneratorService, GameIssue | WordGeneratorLanguageNotSupported | IOException, Game] =
     for
@@ -42,8 +53,7 @@ object Main extends ZIOAppDefault {
 
   override def run = consoleBasedGame.provide(
     DictionaryService.live,
-    WordGeneratorService.live,
-    DictionaryConfig.layer
+    WordGeneratorService.live
   )
 
 }

dictionary/src/main/resources/reference.conf

@@ -1,23 +1,23 @@
 dictionaries-config {
   dictionaries {
     fr {
-      name = "french"
+      name = french
       aff-filename = ${?ZWORDS_FR_AFF_FILENAME}
       dic-filename = ${?ZWORDS_FR_DIC_FILENAME}
     }
     fr-common {
-      name = "french-common"
+      name = french-common
       aff-filename = ${?ZWORDS_FR_AFF_FILENAME}
       dic-filename = ${?ZWORDS_FR_DIC_FILENAME}
       subset-filename = ${?ZWORDS_FR_SUBSET_FILENAME}
     }
     en {
-      name = "english"
+      name = english
       aff-filename = ${?ZWORDS_EN_AFF_FILENAME}
       dic-filename = ${?ZWORDS_EN_DIC_FILENAME}
     }
     en-common {
-      name = "english-common"
+      name = english-common
       aff-filename = ${?ZWORDS_EN_AFF_FILENAME}
       dic-filename = ${?ZWORDS_EN_DIC_FILENAME}
       subset-filename = ${?ZWORDS_EN_SUBSET_FILENAME}

dictionary/src/main/scala/fr/janalyse/zwords/dictionary/DictionaryConfig.scala

@@ -2,22 +2,16 @@ package fr.janalyse.zwords.dictionary
 
 import zio.*
 import zio.config.*
-import zio.config.typesafe.*
 import zio.config.magnolia.*
-import zio.config.ConfigDescriptor.*
+import zio.config.typesafe.*
+import zio.config.toKebabCase
 
 case class DictionaryConfig(name: String, affFilename: Option[String], dicFilename: Option[String], subsetFilename: Option[String])
 
 case class DictionariesConfig(dictionaries: Map[String, DictionaryConfig])
 
-case class RootConfig(dictionariesConfig: DictionariesConfig)
-
 object DictionaryConfig {
-  def layer = ZLayer.fromZIO(
-    read(
-      descriptor[RootConfig]
-        .mapKey(toKebabCase)
-        .from(TypesafeConfigSource.fromResourcePath)
-    ).map(_.dictionariesConfig)
-  )
+  val config =
+    deriveConfig[DictionariesConfig]
+      .nested("dictionaries-config")
 }

dictionary/src/main/scala/fr/janalyse/zwords/dictionary/DictionaryIssue.scala

@@ -0,0 +1,8 @@
+package fr.janalyse.zwords.dictionary
+
+enum DictionaryIssue(message:String) extends Exception(message) {
+  case LanguageNotSupported(language: String) extends DictionaryIssue(s"language $language not supported")
+  case MissingConfiguration(message: String) extends DictionaryIssue(message)
+  case ResourceNotFound(resource: String) extends DictionaryIssue(s"$resource not found")
+  case InternalIssue(message: String, throwable: Option[Throwable]=None) extends DictionaryIssue(message)
+}

dictionary/src/main/scala/fr/janalyse/zwords/dictionary/DictionaryIssues.scala

@@ -21,61 +21,62 @@ import zio.ZIOAspect.*
 trait DictionaryService {
   def languages: UIO[List[String]]
 
-  def count(language: String): IO[DictionaryLanguageNotSupported, Int]
+  def count(language: String): IO[DictionaryIssue, Int]
 
-  def entries(language: String, all: Boolean): IO[DictionaryLanguageNotSupported, List[HunspellEntry]]
+  def entries(language: String, all: Boolean): IO[DictionaryIssue, List[HunspellEntry]]
 
-  def find(language: String, word: String): IO[DictionaryLanguageNotSupported, Option[HunspellEntry]]
+  def find(language: String, word: String): IO[DictionaryIssue, Option[HunspellEntry]]
 
-  def generateWords(language: String, entry: HunspellEntry): IO[DictionaryLanguageNotSupported, List[HunspellEntry]]
+  def generateWords(language: String, entry: HunspellEntry): IO[DictionaryIssue, List[HunspellEntry]]
 }
 
 object DictionaryService {
   def languages: URIO[DictionaryService, Iterable[String]] =
     ZIO.serviceWithZIO(_.languages)
 
-  def count(language: String): ZIO[DictionaryService, DictionaryLanguageNotSupported, Int] =
+  def count(language: String): ZIO[DictionaryService, DictionaryIssue, Int] =
     ZIO.serviceWithZIO(_.count(language))
 
-  def entries(language: String, all: Boolean): ZIO[DictionaryService, DictionaryLanguageNotSupported, List[HunspellEntry]] =
+  def entries(language: String, all: Boolean): ZIO[DictionaryService, DictionaryIssue, List[HunspellEntry]] =
     ZIO.serviceWithZIO(_.entries(language, all))
 
-  def find(language: String, word: String): ZIO[DictionaryService, DictionaryLanguageNotSupported, Option[HunspellEntry]] =
+  def find(language: String, word: String): ZIO[DictionaryService, DictionaryIssue, Option[HunspellEntry]] =
     ZIO.serviceWithZIO(_.find(language, word))
 
-  def generateWords(language: String, entry: HunspellEntry): ZIO[DictionaryService, DictionaryLanguageNotSupported, List[HunspellEntry]] =
+  def generateWords(language: String, entry: HunspellEntry): ZIO[DictionaryService, DictionaryIssue, List[HunspellEntry]] =
     ZIO.serviceWithZIO(_.generateWords(language, entry))
 
-  val live = ZLayer.fromZIO(
-    for {
-      dictionaryConfig <- ZIO.service[DictionariesConfig]
-      dictionaries     <- ZIO.foreach(dictionaryConfig.dictionaries) { (key, dict) =>
-                            Hunspell.loadHunspellDictionary(dict).map(d => key -> d) @@ annotated("language" -> key)
-                          }
-      dictionary       <- ZIO.from(dictionaries)
+  val live: ZLayer[Any, Nothing, DictionaryServiceLive] = ZLayer.fromZIO {
+    val service = for {
+      dictionaryConfig <- ZIO.config(DictionaryConfig.config)
+      dictionaries <- ZIO.foreach(dictionaryConfig.dictionaries) { (key, dict) =>
+        Hunspell.loadHunspellDictionary(dict).map(d => key -> d) @@ annotated("language" -> key)
+      }
+      dictionary <- ZIO.from(dictionaries)
     } yield DictionaryServiceLive(dictionary)
-  )
+    service.orDie
+  }
 }
 
 case class DictionaryServiceLive(dictionaries: Map[String, Hunspell]) extends DictionaryService {
 
   private def getDictionary(language: String) =
-    ZIO.from(dictionaries.get(language)).orElseFail(DictionaryLanguageNotSupported(language))
+    ZIO.from(dictionaries.get(language)).orElseFail(DictionaryIssue.LanguageNotSupported(language))
 
   override val languages: UIO[List[String]] = ZIO.succeed(dictionaries.keys.toList)
 
-  override def count(language: String): IO[DictionaryLanguageNotSupported, Int] = getDictionary(language).map(_.entries.size)
+  override def count(language: String): IO[DictionaryIssue, Int] = getDictionary(language).map(_.entries.size)
 
-  override def entries(language: String, all: Boolean): IO[DictionaryLanguageNotSupported, List[HunspellEntry]] = for {
+  override def entries(language: String, all: Boolean): IO[DictionaryIssue, List[HunspellEntry]] = for {
     dictionary <- getDictionary(language)
     entries    <- if (all) ZIO.succeed(dictionary.entries.flatMap(entry => dictionary.generateWords(entry))) else ZIO.succeed(dictionary.entries)
   } yield entries
 
-  override def find(language: String, word: String): IO[DictionaryLanguageNotSupported, Option[HunspellEntry]] = for {
+  override def find(language: String, word: String): IO[DictionaryIssue, Option[HunspellEntry]] = for {
     dictionary <- getDictionary(language)
   } yield dictionary.entries.find(_.word == word)
 
-  override def generateWords(language: String, entry: HunspellEntry): IO[DictionaryLanguageNotSupported, List[HunspellEntry]] = for {
+  override def generateWords(language: String, entry: HunspellEntry): IO[DictionaryIssue, List[HunspellEntry]] = for {
     dictionary <- getDictionary(language)
   } yield dictionary.generateWords(entry)
 }

dictionary/src/main/scala/fr/janalyse/zwords/dictionary/DictionaryService.scala

@@ -24,7 +24,7 @@ import zio.{Chunk, Console, ZIO}
 import scala.util.matching.Regex
 
 case class HunspellEntry(word: String, flags: Option[String], attributes: Map[String, String]) {
-  val isDiv        = attributes.get("po") == Some("div") // Separator
+  val isDiv        = attributes.get("po").contains("div") // Separator
   val isCommonWord = word.head.isLower                   // Nom commun
   val isCompound   = word.contains('-') || word.contains('\'')
   val isProperNoun = word.head.isUpper
@@ -112,40 +112,40 @@ case class Hunspell(entries: List[HunspellEntry], affixRules: AffixRules) {
 }
 
 object Hunspell {
-  def loadAff(filename: String): IO[DictionaryInternalIssue, AffixRules] = for {
-    file    <- ZIO.attempt(Path(filename)).orElseFail(DictionaryInternalIssue(s"Filename '$filename' is invalid"))
-    bytes   <- Files.readAllBytes(file).orElseFail(DictionaryInternalIssue(s"Couldn't read aff file content $file"))
+  def loadAff(filename: String): IO[DictionaryIssue, AffixRules] = for {
+    file    <- ZIO.attempt(Path(filename)).mapError(th => DictionaryIssue.InternalIssue(s"Filename '$filename' is invalid", Some(th)))
+    bytes   <- Files.readAllBytes(file).orElseFail(DictionaryIssue.ResourceNotFound(filename))
     charset  = Charset.Standard.utf8
     content <- charset.decodeString(bytes)
   } yield AffixRules(content)
 
-  def loadDic(filename: String): IO[DictionaryInternalIssue, List[HunspellEntry]] = for {
-    file    <- ZIO.attempt(Path(filename)).orElseFail(DictionaryInternalIssue(s"Filename '$filename' is invalid"))
-    bytes   <- Files.readAllBytes(file).orElseFail(DictionaryInternalIssue(s"Couldn't file content $file"))
+  def loadDic(filename: String): IO[DictionaryIssue, List[HunspellEntry]] = for {
+    file    <- ZIO.attempt(Path(filename)).mapError(th => DictionaryIssue.InternalIssue(s"Filename '$filename' is invalid", Some(th)))
+    bytes   <- Files.readAllBytes(file).orElseFail(DictionaryIssue.ResourceNotFound(filename))
     charset  = Charset.Standard.utf8
     content <- charset.decodeString(bytes)
     lines    = content.split("\n").toList
-    count   <- ZIO.attempt(lines.headOption.map(_.toInt).getOrElse(0)).orElseFail(DictionaryInternalIssue("Couldn't extract words count"))
+    count   <- ZIO.attempt(lines.headOption.map(_.toInt).getOrElse(0)).orElseFail(DictionaryIssue.InternalIssue("Couldn't extract words count"))
     // _       <- ZIO.log(s"Expecting to find $count hunspell entries")
     specs    = lines.tail
   } yield specs.flatMap(HunspellEntry.fromLine)
 
-  def loadSubsetWords(filename: String): IO[DictionaryInternalIssue, Set[String]] = for {
-    file       <- ZIO.attempt(Path(filename)).orElseFail(DictionaryInternalIssue(s"Filename '$filename' is invalid"))
-    dicBytes   <- Files.readAllBytes(file).orElseFail(DictionaryInternalIssue(s"Couldn't read file content $file"))
+  def loadSubsetWords(filename: String): IO[DictionaryIssue, Set[String]] = for {
+    file       <- ZIO.attempt(Path(filename)).mapError(th => DictionaryIssue.InternalIssue(s"Filename '$filename' is invalid", Some(th)))
+    dicBytes   <- Files.readAllBytes(file).mapError(th => DictionaryIssue.InternalIssue(s"Couldn't read file content $file", Some(th)))
     charset     = Charset.Standard.utf8
     dicContent <- charset.decodeString(dicBytes)
   } yield dicContent.split("\n").map(_.trim).toSet
 
-  def loadHunspellDictionary(dictionaryConfig: DictionaryConfig): IO[DictionaryInternalIssue, Hunspell] =
+  def loadHunspellDictionary(dictionaryConfig: DictionaryConfig): IO[DictionaryIssue, Hunspell] =
     ZIO.logSpan("Hunspell dictionary") {
       for {
         _                  <- ZIO.log("loading")
         // ---------------------------------------------
-        affFilename        <- ZIO.from(dictionaryConfig.affFilename).orElseFail(DictionaryInternalIssue("Aff filename not provided"))
+        affFilename        <- ZIO.from(dictionaryConfig.affFilename).orElseFail(DictionaryIssue.MissingConfiguration("Aff filename not provided"))
         affixRules         <- loadAff(affFilename)
         // ---------------------------------------------
-        dicFilename        <- ZIO.from(dictionaryConfig.dicFilename).orElseFail(DictionaryInternalIssue("Dic filename not provided"))
+        dicFilename        <- ZIO.from(dictionaryConfig.dicFilename).orElseFail(DictionaryIssue.MissingConfiguration("Dic filename not provided"))
         entries            <- loadDic(dicFilename)
         // ---------------------------------------------
         mayBeSubsetFilename = dictionaryConfig.subsetFilename