basic lockfile support

Author: pshirshov

.mobala/steps/run-test.sh

@@ -8,6 +8,7 @@ function run-test() {
   target/graalvm-native-image/baboon \
             --model-dir ./src/test/resources/baboon/ \
             --meta-write-evolution-json baboon-meta.json \
+            --lock-file=./target/baboon.lock \
             :cs \
             --output ./test/cs-stub/BaboonDefinitions/Generated \
             --test-output ./test/cs-stub/BaboonTests/GeneratedTests \
@@ -22,25 +23,26 @@ function run-test() {
             --fixture-output ./test/sc-stub/src/main/scala/generated-fixtures \
             --sc-write-evolution-dict true \
             --sc-wrapped-adt-branch-codecs false
-             
+
   pushd .
   cd ./test/cs-stub
   dotnet build -c Release
   dotnet test -c Release BaboonTests/BaboonTests.csproj
   popd
-  
+
   pushd .
   cd ./test/sc-stub
   sbt +clean +test
   popd
-  
+
   popd
 
   pushd .
 
   target/graalvm-native-image/baboon \
             --model-dir ./src/test/resources/baboon/ \
             --meta-write-evolution-json baboon-meta.json \
+            --lock-file=./target/baboon.lock \
             :cs \
             --output ./test/cs-stub/BaboonDefinitions/Generated \
             --test-output ./test/cs-stub/BaboonTests/GeneratedTests \
@@ -64,37 +66,37 @@ function run-test() {
   cd ./test/cs-stub
   dotnet build -c Debug
   dotnet test -c Debug BaboonTests/BaboonTests.csproj
-  popd 
-  
+  popd
+
   pushd .
   cd ./test/sc-stub
   sbt +clean +test
   popd
-  
+
   popd
-  
+
   pushd .
-  rm -rf ./test/conv-test-cs/ConvTest/Generated 
+  rm -rf ./test/conv-test-cs/ConvTest/Generated
 
 #  sbt "run --model-dir ./test/conv-test  --output ./test/conv-test-cs/ConvTest/Generated"
-  
+
   target/graalvm-native-image/baboon  \
     --model-dir ./test/conv-test \
     :cs \
     --output ./test/conv-test-cs/ConvTest/Generated \
     :scala \
-    --output ./test/conv-test-sc/src/main/scala/generated-main    
+    --output ./test/conv-test-sc/src/main/scala/generated-main
 
   pushd .
   cd ./test/conv-test-cs
   dotnet build
-  dotnet test 
-  popd 
-  
-  pushd . 
+  dotnet test
+  popd
+
+  pushd .
   cd ./test/conv-test-sc
   sbt +clean +test
   popd
-    
-  popd 
+
+  popd
 }

src/main/scala/io/septimalmind/baboon/Baboon.scala

@@ -84,6 +84,7 @@ object Baboon {
             directoryInputs          = directoryInputs,
             targets                  = launchArgs,
             metaWriteEvolutionJsonTo = generalOptions._1.metaWriteEvolutionJson.map(s => Paths.get(s)),
+            lockFile                 = generalOptions._1.lockFile.map(s => Paths.get(s)),
           )
 
           import izumi.distage.modules.support.unsafe.EitherSupport.{defaultModuleEither, quasiIOEither, quasiIORunnerEither}

src/main/scala/io/septimalmind/baboon/BaboonCompiler.scala

@@ -1,18 +1,43 @@
 package io.septimalmind.baboon
 
+import io.circe.generic.semiauto.{deriveCodec, deriveEncoder}
+import io.circe.{Codec, Decoder, Encoder, KeyDecoder, KeyEncoder}
 import io.septimalmind.baboon.parser.model.issues.BaboonIssue
-import io.septimalmind.baboon.parser.model.issues.BaboonIssue.CantCleanupTarget
+import io.septimalmind.baboon.parser.model.issues.BaboonIssue.{CantCleanupTarget, CantReadInput, LockedVersionModified}
 import io.septimalmind.baboon.translator.{BaboonAbstractTranslator, OutputFile}
-import io.septimalmind.baboon.typer.model.BaboonFamily
+import io.septimalmind.baboon.typer.BaboonEnquiries
+import io.septimalmind.baboon.typer.model.{BaboonFamily, Domain, Pkg, UnmodifiedSince, Version}
 import io.septimalmind.baboon.util.{BLogger, BaboonMetagen}
 import izumi.functional.bio.unsafe.MaybeSuspend2
 import izumi.functional.bio.{Error2, F}
 import izumi.fundamentals.collections.nonempty.NEList
+import izumi.fundamentals.platform.crypto.IzSha256HashFunction
 import izumi.fundamentals.platform.files.IzFiles
 
 import java.nio.charset.StandardCharsets
 import java.nio.file.{Files, Path, StandardOpenOption}
 
+case class SigId(value: String) extends AnyVal
+
+case class VersionLock(
+  version: Version,
+  sigId: SigId,
+)
+
+case class Locks(
+  locks: Map[Pkg, List[VersionLock]]
+)
+
+object LockCodecs {
+  implicit lazy val pkgKeyEncoder: KeyEncoder[Pkg]       = KeyEncoder.encodeKeyString.contramap(_.toString)
+  implicit lazy val pkgKeyDecoder: KeyDecoder[Pkg]       = KeyDecoder.decodeKeyString.map(s => Pkg(NEList.unsafeFrom(s.split('.').toList)))
+  implicit lazy val versionCodec: Codec[Version]         = Codec.from(Decoder.decodeString.map(s => Version(s)), Encoder.encodeString.contramap(_.version))
+  implicit lazy val sigidCodec: Codec[SigId]             = Codec.from(Decoder.decodeString.map(s => SigId(s)), Encoder.encodeString.contramap(_.value))
+  implicit lazy val versionLockCodec: Codec[VersionLock] = deriveCodec
+  implicit lazy val lockscodec: Codec[Locks]             = deriveCodec
+
+}
+
 trait BaboonCompiler[F[+_, +_]] {
   def run(target: CompilerTarget, model: BaboonFamily): F[NEList[BaboonIssue], Unit]
 }
@@ -23,13 +48,15 @@ object BaboonCompiler {
     options: CompilerOptions,
     logger: BLogger,
     metagen: BaboonMetagen,
+    enq: BaboonEnquiries,
   ) extends BaboonCompiler[F] {
 
     override def run(target: CompilerTarget, model: BaboonFamily): F[NEList[BaboonIssue], Unit] = {
 
       for {
         _ <- cleanupTargetPaths(target.output)
         _ <- writeEvolutionJson(target, model)
+        _ <- validateLock(model)
 
         _          <- F.maybeSuspend(logger.message(s"${target.id}: generating output..."))
         translated <- translator.translate(model)
@@ -47,6 +74,62 @@ object BaboonCompiler {
       } yield {}
     }
 
+    // TODO: move this into a separate component
+    private def validateLock(model: BaboonFamily): F[NEList[BaboonIssue], Unit] = {
+      import LockCodecs.*
+      import io.circe.syntax.*
+
+      val currentSigs = Locks(model.domains.map {
+        case (pkg, lineage) =>
+          val versions = lineage.versions.toSeq.map {
+            case (ver, dom) =>
+              VersionLock(ver, sigOf(dom))
+          }.toList
+          (pkg, versions)
+      }.toMap)
+
+      options.lockFile match {
+        case Some(lockfilePath) if lockfilePath.toFile.exists() =>
+          for {
+            existingSigs <- (for {
+              content <- F.maybeSuspend(IzFiles.readString(lockfilePath))
+              parsed  <- F.fromEither(io.circe.parser.parse(content))
+              out     <- F.fromEither(parsed.as[Locks])
+            } yield {
+              out
+            }).catchAll(e => F.fail(NEList(CantReadInput(lockfilePath.toString, e))))
+            _ <- compareSigs(model, currentSigs, existingSigs)
+          } yield {}
+
+        case Some(lockfilePath) =>
+          F.maybeSuspend(IzFiles.writeUtfString(lockfilePath, currentSigs.asJson.spaces2))
+        case None =>
+          F.unit
+      }
+    }
+
+    private def compareSigs(model: BaboonFamily, currentSigs: Locks, existingSigs: Locks): F[NEList[BaboonIssue], Unit] = {
+      val ci        = index(currentSigs)
+      val ei        = index(existingSigs)
+      val different = ci.filter { case (k, id) => ei.contains(k) && !ei.get(k).contains(id) }.filterNot { case ((pkg, v), _) => model.domains(pkg).evolution.latest == v }
+      F.ifThenFail(different.nonEmpty)(NEList.unsafeFrom(different.map { case ((pkg, v), _) => LockedVersionModified(pkg, v) }.toList))
+    }
+
+    private def index(currentSigs: Locks): Map[(Pkg, Version), SigId] = {
+      currentSigs.locks.flatMap {
+        case (p, v) =>
+          v.map(v => ((p, v.version), v.sigId))
+      }.toMap
+    }
+
+    private def sigOf(dom: Domain): SigId = {
+      val repr = dom.typeMeta.view.toSeq.map {
+        case (id, meta) =>
+          s"[${enq.wrap(id)}:${meta.deepId.id}]"
+      }.mkString("\n")
+      SigId(IzSha256HashFunction.hash(repr))
+    }
+
     private def writeFile(content: OutputFile, tgt: Path): F[NEList[BaboonIssue], Unit] = {
       F.fromAttempt {
         tgt.getParent.toFile.mkdirs()

src/main/scala/io/septimalmind/baboon/CLIOptions.scala

@@ -83,6 +83,8 @@ case class ScCLIOptions(
 case class CLIOptions(
   @HelpMessage("A list of *.baboon files to process (can be combined with --model-dir)")
   model: List[String],
+  @HelpMessage("A file used to track model signatures")
+  lockFile: Option[String],
   @HelpMessage("A directory to recursively read all the *.baboon files from")
   modelDir: List[String],
   @HelpMessage("Produces additional debug messages. Do not use.")

src/main/scala/io/septimalmind/baboon/CompilerOptions.scala

@@ -101,6 +101,7 @@ final case class OutputOptions(
 final case class CompilerOptions(
   individualInputs: Set[Path],
   directoryInputs: Set[Path],
+  lockFile: Option[Path],
   debug: Boolean,
   targets: Seq[CompilerTarget],
   metaWriteEvolutionJsonTo: Option[Path],

src/main/scala/io/septimalmind/baboon/parser/model/issues/BaboonIssue.scala

@@ -153,6 +153,8 @@ object BaboonIssue {
   //
   sealed trait VerificationIssue extends BaboonIssue
 
+  case class LockedVersionModified(pkg: Pkg, version: Version) extends VerificationIssue
+
   case class MissingTypeDef(domain: Domain, missing: Set[TypeId]) extends VerificationIssue
 
   case class ReferentialCyclesFound(domain: Domain, loops: Set[LoopDetector.Cycles[TypeId]]) extends VerificationIssue

src/main/scala/io/septimalmind/baboon/parser/model/issues/IssuePrinter.scala

@@ -468,6 +468,11 @@ object IssuePrinter {
          |""".stripMargin
     }
 
+  implicit val lockedVersionModified: IssuePrinter[LockedVersionModified] =
+    (issue: LockedVersionModified) => {
+      s"""Model ${issue.pkg.toString}@${issue.version} was modified but it's not the latest version so it's locked with the lockfile""".stripMargin
+    }
+
   implicit val referentialCyclesFoundPrinter: IssuePrinter[ReferentialCyclesFound] =
     (issue: ReferentialCyclesFound) => {
       val stringLoops = issue.loops.toList
@@ -729,6 +734,7 @@ object IssuePrinter {
   }
 
   implicit val verificationIssuePrinter: IssuePrinter[VerificationIssue] = {
+    case i: LockedVersionModified  => apply[LockedVersionModified].stringify(i)
     case i: MissingTypeDef         => apply[MissingTypeDef].stringify(i)
     case i: ReferentialCyclesFound => apply[ReferentialCyclesFound].stringify(i)
     case i: IncorrectRootFound     => apply[IncorrectRootFound].stringify(i)

src/main/scala/io/septimalmind/baboon/typer/BaboonTyper.scala

@@ -10,6 +10,7 @@ import izumi.fundamentals.collections.nonempty.NEList
 import izumi.fundamentals.graphs.struct.IncidenceMatrix
 import izumi.fundamentals.graphs.tools.{Toposort, ToposortLoopBreaker}
 import izumi.fundamentals.graphs.{DG, GraphMeta}
+import izumi.fundamentals.platform.crypto.{IzHash, IzSha256HashFunction}
 
 import scala.annotation.tailrec
 import scala.collection.mutable
@@ -208,9 +209,10 @@ object BaboonTyper {
     ): F[NEList[BaboonIssue.TyperIssue], DeepSchemaId] = {
       for {
         repr <- F.pure(deepSchemaRepr(id, defs, List.empty))
+        fullRepr = s"[${enquiries.wrap(id)};${repr
+            .mkString(",")}]"
       } yield {
-        DeepSchemaId(s"[${enquiries.wrap(id)};${repr
-            .mkString(",")}]")
+        DeepSchemaId(IzSha256HashFunction.hash(fullRepr))
       }
     }
 

src/test/scala/io/septimalmind/baboon/tests/BaboonTest.scala

@@ -23,6 +23,7 @@ abstract class BaboonTest[F[+_, +_]: TagKK: BaboonTestModule] extends Spec2[F]()
           individualInputs         = Set.empty,
           directoryInputs          = Set(Paths.get("./src/test/resources/baboon")),
           metaWriteEvolutionJsonTo = None,
+          lockFile                 = Some(Paths.get("./target/baboon.lock")),
           targets = Seq(
             CSTarget(
               id = "C#",