refactoring: upgrade to metarules 0.7.1 (new TileOrientationCache implementation)

Author: memo33

build.sbt

@@ -20,7 +20,7 @@ import io.github.memo33.metarules.meta._, com.sc4nam.module, module.syntax._
 import Implicits._, Network._, Flags._, RotFlip._, Rule.{CopyTile => %}, group.SymGroup._
 lazy val resolve = module.Main.resolveSafely
 lazy val preimage = module.ReverseResolver.create()
-implicit lazy val context: RuleTransducer.Context = RuleTransducer.Context(resolve, module.RegenerateTileOrientationCache.loadCache(), module.MirrorVariants.preprocessor)
+implicit lazy val context: RuleTransducer.Context = RuleTransducer.Context(module.Main.resolve, module.RegenerateTileOrientationCache.loadCache(), module.MirrorVariants.preprocessor)
 def transduce(rule: Rule[SymTile]): Unit = RuleTransducer(rule)(context).map(_.toRul2String).foreach(println)
 """
 
@@ -71,4 +71,4 @@ libraryDependencies += "tv.cntt" %% "scaposer" % "1.11.1" cross CrossVersion.for
 
 libraryDependencies += "io.github.memo33" %% "scdbpf" % "0.2.0" cross CrossVersion.for3Use2_13
 
-libraryDependencies += "io.github.memo33" %% "metarules" % "0.7.0"
+libraryDependencies += "io.github.memo33" %% "metarules" % "0.7.1"

src/main/scala/module/CompileAllMetarules.scala

@@ -31,7 +31,7 @@ object CompileAllMetarules {
 
   /** Add additional rule generators here.
     */
-  def compileMetarulesOnce(tileOrientationCache: collection.mutable.Map[Int, Set[RotFlip]]): Unit = {
+  def compileMetarulesOnce(tileOrientationCache: RuleTransducer.TileOrientationCache): Unit = {
     LOGGER.info("compiling FlexFly metarule code")
     flexfly.CompileFlexFlyCode.start(tileOrientationCache = tileOrientationCache)
     LOGGER.info("compiling RRW metarule code")

src/main/scala/module/Main.scala

@@ -25,15 +25,15 @@ abstract class AbstractMain {
   lazy val resolveSafely: IdResolver = new PartialFunction[Tile, IdTile] {
     def isDefinedAt(tile: Tile) = resolve.isDefinedAt(tile)
     def apply(tile: Tile) = try resolve.apply(tile) catch {
-      case scala.util.control.NonFatal(e) =>
-        throw new IllegalArgumentException(s"ID resolution failed for tile $tile", e)
+      case e: RuleTransducer.ResolutionFailed => throw e
+      case scala.util.control.NonFatal(e) => throw new RuleTransducer.ResolutionFailed(tile, rule = None, reason = e, frame = None)
     }
   }
 
   def main(args: Array[String]): Unit = start()
 
   /** Creates a generator with a new context, runs its start method and outputs the resulting RUL2 code to file. */
-  def start(file: File = file, tileOrientationCache: collection.mutable.Map[Int, Set[RotFlip]] = null): Unit = {
+  def start(file: File = file, tileOrientationCache: RuleTransducer.TileOrientationCache = null): Unit = {
     if (tileOrientationCache == null) {
       RegenerateTileOrientationCache.withCache { cache =>
         start(file, cache)

src/main/scala/module/RegenerateTileOrientationCache.scala

@@ -2,6 +2,7 @@ package com.sc4nam.module
 
 import java.io.File
 import io.github.memo33.metarules.meta.RotFlip
+import syntax.RuleTransducer.TileOrientationCache
 
 /** Manages the tile orientation cache. The cache is necessary to maintain
   * information about non-standard orientations:
@@ -23,19 +24,24 @@ object RegenerateTileOrientationCache {
 
   /** Repeatedly compiles the metarule code until the cache does not get changed anymore.
     */
-  def compileMetarulesUntilStable(tileOrientationCache: collection.mutable.Map[Int, Set[RotFlip]]): Unit = {
+  def compileMetarulesUntilStable(cache: collection.mutable.Map[Int, Set[RotFlip]]): Unit = {
+    val tileOrientationCache = TileOrientationCache(cache = cache, accum = collection.mutable.Map.empty[Int, Set[RotFlip]])
     var j = 0
     var stabilized = false
-    var previous: collection.immutable.Map[Int, Set[RotFlip]] = tileOrientationCache.toMap
-    while (j < 3 && !stabilized) {
-      LOGGER.info(s"> metarules compilation: iteration $j")
+    val maxIter = 5
+    while (j < 5 && !stabilized) {
       j += 1
+      LOGGER.info(s"> metarules compilation: iteration $j")
       CompileAllMetarules.compileMetarulesOnce(tileOrientationCache)
-      val next = tileOrientationCache.toMap
-      if (next == previous) {
+      if (tileOrientationCache.accum.nonEmpty) {
+        tileOrientationCache.cache ++= tileOrientationCache.accum
+        tileOrientationCache.accum.clear()
+        if (j == maxIter) {
+          LOGGER.warning(s"Tile orientation cache could not be regenerated in $maxIter iterations. Increase the number of iterations or check if there is a bug.")
+        }
+      } else {
         stabilized = true
       }
-      previous = next
     }
   }
 
@@ -50,7 +56,7 @@ object RegenerateTileOrientationCache {
     }
   }
 
-  def loadCache(): collection.mutable.Map[Int, Set[RotFlip]] = {
+  def loadCache(): TileOrientationCache = {
     scala.util.Using.resource(new java.util.Scanner(cacheFile, "UTF-8")) { scanner =>
       val cache = collection.mutable.Map.empty[Int, Set[RotFlip]]
       while(scanner.hasNextLine()) {
@@ -62,21 +68,18 @@ object RegenerateTileOrientationCache {
           cache(id) = orientations
         }
       }
-      cache
+      TileOrientationCache(cache = cache, accum = collection.mutable.Map.empty[Int, Set[RotFlip]])
     }
   }
 
   /** Loads the cache and gives a warning at the end if it was changed.
     */
-  def withCache[U](body: collection.mutable.Map[Int, Set[RotFlip]] => U): U = {
-    var previous: collection.immutable.Map[Int, Set[RotFlip]] = null
-    val cache = loadCache()
+  def withCache[U](body: TileOrientationCache => U): U = {
+    val tileOrientationCache = loadCache()
     try {
-      previous = cache.toMap
-      body(cache)
+      body(tileOrientationCache)
     } finally {
-      assert(previous != null)
-      if (previous != cache.toMap) {
+      if (tileOrientationCache.accum.nonEmpty) {
         LOGGER.warning(s"The file ${cacheFile} is outdated. Rebuild it with `sbt regenerateTileOrientationCache` and commit the changes.")
       }
     }

src/test/scala/meta/RuleTransducerSpec.scala

@@ -10,21 +10,20 @@ import RuleTransducer._
 class RuleTransducerSpec extends AnyWordSpec with Matchers {
 
   val resolver = new module.RhwResolver orElse new module.NwmResolver orElse new module.MiscResolver
-  val tileOrientationCache = collection.mutable.Map.empty[Int, Set[RotFlip]]
-  val context = RuleTransducer.Context(resolver, tileOrientationCache, module.MirrorVariants.preprocessor)
+  val context = RuleTransducer.Context(resolver, preprocess = module.MirrorVariants.preprocessor)
 
   "preprocessor" should {
     "produce expected number of rules for Tla3" in {
       val orth: Seq[Rule[SymTile]] = context.preprocess( Tla3~WE | (Road ~> Tla3)~WE ).toSeq
       orth should have size (1)
       orth.asInstanceOf[Seq[Rule[Tile]]].exists(_.exists(_.segs.exists(s => s.flags.manifest == Flag.RightSpinBi && s.flags.exists(_ == 2)))) should be (false)
-      createRules(orth.head.map(_.toIdSymTile(resolver)), tileOrientationCache).toSeq should have size (2)
+      createRules(orth.head.map(_.toIdSymTile(resolver)), context.tileOrientationCache.cache, context.tileOrientationCache.accum).toSeq should have size (2)
 
       context.preprocess( Tla3~WE & Road~NS | (Road ~> Tla3)~WE ).toSeq should have size (1)
       val diag = context.preprocess( Tla3~WE & Road~WS | (Road ~> Tla3)~WE ).toSeq
       diag should have size (2)
       for (r <- diag) {
-        createRules(r.map(_.toIdSymTile(resolver)), tileOrientationCache).toSeq should have size (2)
+        createRules(r.map(_.toIdSymTile(resolver)), context.tileOrientationCache.cache, context.tileOrientationCache.accum).toSeq should have size (2)
       }
     }
   }
@@ -53,7 +52,7 @@ class RuleTransducerSpec extends AnyWordSpec with Matchers {
     "find RHS for TLA" in {
       val rule = (Tla3~WE | (Road ~> Tla3)~(2,0,11,0)) map makeTileLeft map (_.toIdSymTile(resolver))
       possibleMapOrientation(Set(R0F0, R1F0), R3F0/R2F1, Quotient.Dih4, R1F1/R2F1) should not be (Symbol("empty"))
-      createRules(rule, tileOrientationCache)
+      createRules(rule, context.tileOrientationCache.cache, context.tileOrientationCache.accum)
     }
     "resolve diagonal TLA intersections" in {
       val t1 = makeTileLeft(Tla3~ES & Road~WS)