Improved separate updating of configured and placed features

mschae23 · mschae23 · commit d36658572c59 · 2021-12-14T18:47:07.000+01:00
diff --git a/build.sbt b/build.sbt
@@ -5,7 +5,7 @@ lazy val root = project
     .settings(
         name := "minecraft-worldgen-updater",
         organization := "de.martenschaefer",
-        version := "2.0.0-pre.7",
+        version := "2.0.0",
         homepage := Some(url("https://github.com/mschae23/minecraft-worldgen-updater")),
 
         scalaVersion := scala3Version,
diff --git a/src/main/scala/FeatureUpdater.scala b/src/main/scala/FeatureUpdater.scala
@@ -5,20 +5,21 @@ import java.nio.file.{ Files, LinkOption, Path, Paths }
 import java.util.Scanner
 import scala.jdk.CollectionConverters.IterableHasAsScala
 import scala.util.Using
-import de.martenschaefer.data.serialization.{ AlternativeError, Codec, Element, ElementError, ElementNode, JsonCodecs, RecordParseError, ValidationError }
+import de.martenschaefer.data.Result
+import de.martenschaefer.data.serialization.{ AlternativeError, Codec, Element, ElementError, ElementNode, Encoder, JsonCodecs, RecordParseError, ValidationError }
 import de.martenschaefer.data.serialization.JsonCodecs.given
 import de.martenschaefer.data.util.DataResult.*
-import de.martenschaefer.data.util.Lifecycle
+import de.martenschaefer.data.util.*
 import feature.ConfiguredFeature
 import util.*
 
 object FeatureUpdater {
-    def process[T: Codec](originPath: Path, targetPath: Path,
+    def process[T: Codec](inputPath: Path, outputPath: Path,
                           processor: T => ProcessResult[T],
                           getPostProcessWarnings: T => List[ElementError],
-                          fileNameRegex: String)(using flags: Flags): Unit = {
-        if (originPath.equals(targetPath) && !Flag.AssumeYes.get) {
-            println(colored("Input and output path are the same. The origin files will be overwritten.", Console.YELLOW))
+                          fileNameRegex: String, featureType: Option[String])(using flags: Flags): Option[WarningType] = {
+        if (inputPath.equals(outputPath) && !Flag.AssumeYes.get) {
+            println(colored("Input and output path are the same. The input files will be overwritten.", Console.YELLOW))
             println("Continue (y / N)? ")
 
             Using(new Scanner(System.in)) { scanner =>
@@ -30,26 +31,18 @@ object FeatureUpdater {
                     }
 
                     println(colored("Aborting.", Console.YELLOW))
-                    return
+                    return None
                 }
             }
         }
 
-        if (Files.isDirectory(originPath)) {
-            val warningType = this.processDirectory(originPath, targetPath, originPath,
-                processor, getPostProcessWarnings, fileNameRegex)
-
-            val notice = warningType match {
-                case WarningType.Error =>
-                    colored("Done with errors.", WarningType.Error.color)
-                case WarningType.Warning =>
-                    colored("Done with warnings.", WarningType.Warning.color)
-                case _ => colored("Done.", WarningType.Okay.color)
-            }
-
-            println(notice)
-        } else if (Files.isRegularFile(originPath))
-            this.processFeatureFile(originPath, targetPath, processor, getPostProcessWarnings)
+        if (Files.isDirectory(inputPath)) {
+            Some(this.processDirectory(inputPath, outputPath, inputPath,
+                processor, getPostProcessWarnings, fileNameRegex, featureType))
+        } else if (Files.isRegularFile(inputPath))
+            Some(this.processFeatureFile(inputPath, outputPath, processor, getPostProcessWarnings).warningType)
+        else
+            None
     }
 
     def processFeatureFile[T: Codec](originFile: Path, targetFile: Path,
@@ -68,27 +61,30 @@ object FeatureUpdater {
         result
     }
 
-    def processDirectory[T: Codec](originDirectory: Path, targetDirectory: Path,
+    def processDirectory[T: Codec](inputDirectory: Path, outputDirectory: Path,
                                    startingDirectory: Path,
                                    processor: T => ProcessResult[T],
                                    getPostProcessWarnings: T => List[ElementError],
-                                   fileNameRegex: String, recursive: Boolean = false)(using flags: Flags): WarningType = {
-        if (!Files.exists(originDirectory) || !Files.isDirectory(originDirectory))
-            throw new IllegalArgumentException(s"${originDirectory.getFileName} doesn't exist or is not a directory")
+                                   fileNameRegex: String, featureType: Option[String],
+                                   recursive: Boolean = false)(using flags: Flags): WarningType = {
+        if (!Files.exists(inputDirectory) || !Files.isDirectory(inputDirectory))
+            throw new IllegalArgumentException(s"${inputDirectory.getFileName} doesn't exist or is not a directory")
 
-        if (Files.exists(targetDirectory) && !Files.isDirectory(targetDirectory))
-            throw new IllegalArgumentException(s"${targetDirectory.getFileName} is not a directory")
+        if (Files.exists(outputDirectory) && !Files.isDirectory(outputDirectory))
+            throw new IllegalArgumentException(s"${outputDirectory.getFileName} is not a directory")
 
-        Files.createDirectories(targetDirectory)
+        Files.createDirectories(outputDirectory)
 
         var foundWarnings = false
         var foundErrors = false
 
-        Using(Files.newDirectoryStream(originDirectory)) { directoryStream =>
+        val featureTypeString = featureType.map(_ + " ").getOrElse("")
+
+        Using(Files.newDirectoryStream(inputDirectory)) { directoryStream =>
             for (path <- directoryStream.asScala) {
                 if (Flag.Recursive.get && Files.isDirectory(path)) {
-                    processDirectory(path, targetDirectory.resolve(path.getFileName), startingDirectory,
-                        processor, getPostProcessWarnings, fileNameRegex, recursive = true) match {
+                    processDirectory(path, outputDirectory.resolve(path.getFileName), startingDirectory,
+                        processor, getPostProcessWarnings, fileNameRegex, featureType, recursive = true) match {
                         case WarningType.Error => foundErrors = true
                         case WarningType.Warning => foundWarnings = true
                         case _ =>
@@ -98,9 +94,9 @@ object FeatureUpdater {
                 if (path.getFileName.toString.matches(fileNameRegex)) {
                     val relativePath = startingDirectory.relativize(path)
 
-                    println(s"[info] Processing $relativePath")
+                    println(s"[info] Processing $featureTypeString$relativePath")
 
-                    val result = processFile[T](path, targetDirectory.resolve(path.getFileName), processor, getPostProcessWarnings)
+                    val result = processFile[T](path, outputDirectory.resolve(path.getFileName), processor, getPostProcessWarnings)
 
                     result match {
                         case FileProcessResult.Errors(errors) => println()
@@ -122,39 +118,87 @@ object FeatureUpdater {
         else WarningType.Okay
     }
 
-    def processFile[T: Codec](originFile: Path, targetFile: Path,
-                              processor: T => ProcessResult[T],
-                              getPostProcessWarnings: T => List[ElementError])(using Flags): FileProcessResult = {
-        var lifecycle = Lifecycle.Stable
-        var foundWarnings = false
-        var warnings: List[ElementError] = List.empty
-
-        val originString: String = try {
-            read(originFile)
+    def readFeature[T: Codec](inputPath: Path): Result[T] = {
+        val inputString: String = try {
+            read(inputPath)
         } catch {
             case e: IOException => {
-                warnings ::= createErrorForException("read", Some("IO"), e)
-                return FileProcessResult.Errors(warnings)
+                return Failure(List(createErrorForException("read", Some("IO"), e)))
             }
 
             case e: Exception => {
-                warnings ::= createErrorForException("read", None, e)
-                return FileProcessResult.Errors(warnings)
+                return Failure(List(createErrorForException("read", None, e)))
+            }
+        }
+
+        try {
+            Codec[T].decode(inputString)
+        } catch {
+            case e: Exception => {
+                Failure(List(createErrorForException("decoding", None, e)))
             }
         }
+    }
 
-        val originFeature: T = try {
-            Codec[T].decode(originString) match {
-                case Success(feature, l) => lifecycle += l
-                    feature
-                case Failure(errors, _) => return FileProcessResult.Errors(errors.toList)
+    def encodeFeature[T, E](feature: T)(using Codec[T], Encoder[Element, E]): Result[E] = {
+        try {
+            Codec[T].encode(feature)
+        } catch {
+            case e: Exception => {
+                Failure(List(createErrorForException("encoding", None, e)))
             }
+        }
+    }
+
+    def writeFeature(targetPath: Path, feature: String): Option[List[ElementError]] = {
+        try {
+            write(targetPath, feature)
+            None
         } catch {
+            case e: IOException => {
+                Some(List(createErrorForException("write", None, e)))
+            }
+
             case e: Exception => {
-                warnings ::= createErrorForException("decoding", None, e)
-                return FileProcessResult.Errors(warnings)
+                Some(List(createErrorForException("write", None, e)))
             }
         }
+    }
+
+    def getWarningForLifecycle(lifecycle: Lifecycle): Option[ElementError] = lifecycle match {
+        case Lifecycle.Internal =>
+            Some(ValidationError(_ => "Implementation details of Worldgen Updater are used."))
+        case Lifecycle.Experimental =>
+            Some(ValidationError(_ => "Experimental features are used."))
+        case Lifecycle.Deprecated(since) =>
+            Some(ValidationError(_ => s"Features that are deprecated since v$since are used."))
+        case _ => None
+    }
+
+    def printDone(warningType: WarningType)(using Flags): Unit = {
+        println(warningType match {
+            case WarningType.Error =>
+                colored("Done with errors.", WarningType.Error.color)
+            case WarningType.Warning =>
+                colored("Done with warnings.", WarningType.Warning.color)
+            case _ => colored("Done.", WarningType.Okay.color)
+        })
+    }
+
+    def processFile[T: Codec](inputPath: Path, outputPath: Path,
+                              processor: T => ProcessResult[T],
+                              getPostProcessWarnings: T => List[ElementError])(using Flags): FileProcessResult = {
+        var lifecycle = Lifecycle.Stable
+        var foundWarnings = false
+
+        val originFeature: T = readFeature(inputPath) match {
+            case Success(feature, l) => lifecycle = l
+                feature
+
+            case Failure(errors, _) => return FileProcessResult.Errors(errors)
+        }
+
+        var warnings: List[ElementError] = List.empty
 
         val targetFeature: T = try {
             val targetFeatureWriter: ProcessResult[T] = processor(originFeature)
@@ -170,51 +214,19 @@ object FeatureUpdater {
             }
         }
 
-        if (warnings.nonEmpty) foundWarnings = true
-
-        val targetFeatureString: String = try {
-            Codec[T].encode(targetFeature)(using JsonCodecs.prettyJsonEncoder) match {
-                case Success(json, l) => lifecycle += l
-                    json
-                case Failure(errors, _) => {
-                    return FileProcessResult.Errors(errors.toList)
-                }
-            }
-        } catch {
-            case e: Exception => {
-                warnings ::= createErrorForException("encoding", None, e)
-                return FileProcessResult.Errors(warnings)
-            }
-        }
-
-        lifecycle match {
-            case Lifecycle.Internal =>
-                warnings = ValidationError(_ => "Implementation details of Worldgen Updater are used.") :: warnings
-                foundWarnings = true
-            case Lifecycle.Experimental =>
-                warnings = ValidationError(_ => "Experimental features are used.") :: warnings
-                foundWarnings = true
-            case Lifecycle.Deprecated(since) =>
-                warnings = ValidationError(_ => s"Features that are deprecated since v$since are used.") :: warnings
-                foundWarnings = true
-            case _ =>
+        val targetFeatureString: String = encodeFeature(targetFeature)(using Codec[T], JsonCodecs.prettyJsonEncoder) match {
+            case Success(s, l) => lifecycle += l
+                s
+            case Failure(errors, _) => return FileProcessResult.Errors(errors)
         }
 
-        try {
-            write(targetFile, targetFeatureString)
-        } catch {
-            case e: IOException => {
-                warnings ::= createErrorForException("write", Some("IO"), e)
-                return FileProcessResult.Errors(warnings)
-            }
+        // Add lifecycle warning
+        getWarningForLifecycle(lifecycle).foreach(error => warnings = error :: warnings)
 
-            case e: Exception => {
-                warnings ::= createErrorForException("write", None, e)
-                return FileProcessResult.Errors(warnings)
-            }
-        }
+        // Write feature to file
+        writeFeature(outputPath, targetFeatureString).foreach(errors => warnings = warnings ::: errors)
 
-        if (foundWarnings) FileProcessResult.Warnings(warnings) else FileProcessResult.Normal
+        if (warnings.isEmpty) FileProcessResult.Normal else FileProcessResult.Warnings(warnings)
     }
 
     private def createErrorForException(phase: String, kind: Option[String], e: Exception): ElementError =
diff --git a/src/main/scala/FileProcessResult.scala b/src/main/scala/FileProcessResult.scala
@@ -2,10 +2,10 @@ package de.martenschaefer.minecraft.worldgenupdater
 
 import de.martenschaefer.data.serialization.ElementError
 
-enum FileProcessResult {
-    case Normal
-    case Warnings(val warnings: List[ElementError])
-    case Errors(val errors: List[ElementError])
+enum FileProcessResult(val warningType: WarningType) {
+    case Normal extends FileProcessResult(WarningType.Okay)
+    case Warnings(val warnings: List[ElementError]) extends FileProcessResult(WarningType.Warning)
+    case Errors(val errors: List[ElementError]) extends FileProcessResult(WarningType.Error)
 
     def +(other: FileProcessResult): FileProcessResult = other match {
         case Errors(errors) => this match {
diff --git a/src/main/scala/UpdaterMain.scala b/src/main/scala/UpdaterMain.scala
@@ -28,14 +28,19 @@ object UpdaterMain {
                 Flag.UpdateOnly -> ("update-only", Some('u')),
                 Flag.Colored -> ("colored", None),
                 Flag.Recursive -> ("recursive", Some('r')),
-                Flag.Verbose -> ("verbose", Some('v')))) { flags =>
+                Flag.Verbose -> ("verbose", Some('v')))) { flagsMap =>
+                given flags: Flags = flagsMap
+
                 defaultedArgumentFlag("matches", None, CommandArgument.string("file name regex"), ".+\\.json$") { fileNameRegex =>
                     literal("features") {
-                        literalFlag("legacy", None) { // Legacy; from configured features to placed features
+                        // Legacy; update configured features to placed features
+                        literalFlag("legacy", None) {
                             argument(CommandArgument.string("input")) { input =>
                                 argument(CommandArgument.string("output")) { output =>
                                     result {
-                                        this.processPlacedFeatures(input, output, fileNameRegex)(using flags)
+                                        val warningType = this.processPlacedFeatures(input, output, fileNameRegex, legacy = true)
+
+                                        warningType.foreach(FeatureUpdater.printDone)
                                     }
                                 }
                             }
@@ -48,9 +53,20 @@ object UpdaterMain {
                                     argument(CommandArgument.string("placed feature output")) { placedOutput =>
                                         result {
                                             // TODO find a better solution for this
-                                            this.processConfiguredFeatures(configuredInput, configuredOutput, fileNameRegex)(using flags)
+                                            var warningType = this.processConfiguredFeatures(configuredInput, configuredOutput, fileNameRegex)
                                             println()
-                                            this.processPlacedFeatures(placedInput, placedOutput, fileNameRegex)(using flags)
+                                            this.processPlacedFeatures(placedInput, placedOutput, fileNameRegex, legacy = false).foreach {
+                                                case WarningType.Error => warningType = Some(WarningType.Error)
+
+                                                case WarningType.Warning =>
+                                                    if (warningType.contains(WarningType.Okay) || warningType.isEmpty)
+                                                        warningType = Some(WarningType.Warning)
+
+                                                case WarningType.Okay => if (warningType.isEmpty)
+                                                    warningType = Some(WarningType.Okay)
+                                            }
+
+                                            warningType.foreach(FeatureUpdater.printDone)
                                         }
                                     }
                                 }
@@ -76,9 +92,9 @@ object UpdaterMain {
         }
     }
 
-    def processConfiguredFeatures(origin: String, target: String, fileNameRegex: String)(using flags: Flags): Unit = {
-        val originPath = Paths.get(origin)
-        val targetPath = Paths.get(target)
+    def processConfiguredFeatures(origin: String, target: String, fileNameRegex: String)(using flags: Flags): Option[WarningType] = {
+        val inputPath = Paths.get(origin)
+        val outputPath = Paths.get(target)
 
         val context = FeatureUpdateContext(flags(Flag.UpdateOnly))
 
@@ -94,10 +110,10 @@ object UpdaterMain {
         val getFeaturePostProcessWarnings: ConfiguredFeature[_, _] => List[ElementError] =
             feature => feature.feature.getPostProcessWarnings(feature.config, context)
 
-        FeatureUpdater.process(originPath, targetPath, featureProcessor, getFeaturePostProcessWarnings, fileNameRegex)
+        FeatureUpdater.process(inputPath, outputPath, featureProcessor, getFeaturePostProcessWarnings, fileNameRegex, Some("configured feature"))
     }
 
-    def processPlacedFeatures(origin: String, target: String, fileNameRegex: String)(using flags: Flags): Unit = {
+    def processPlacedFeatures(origin: String, target: String, fileNameRegex: String, legacy: Boolean)(using flags: Flags): Option[WarningType] = {
         val originPath = Paths.get(origin)
         val targetPath = Paths.get(target)
 
@@ -108,7 +124,8 @@ object UpdaterMain {
 
         val getFeaturePostProcessWarnings: PlacedFeatureReference => List[ElementError] = _.getPostProcessWarnings(using context)
 
-        FeatureUpdater.process(originPath, targetPath, featureProcessor, getFeaturePostProcessWarnings, fileNameRegex)
+        FeatureUpdater.process(originPath, targetPath, featureProcessor, getFeaturePostProcessWarnings, fileNameRegex,
+            if (legacy) None else Some("placed feature"))
     }
 
     def printHelp(): Unit = {
@@ -122,6 +139,7 @@ object UpdaterMain {
         printFlag(None, "colored", "Use colored output")
         printFlag(Some('r'), "recursive", "Recursively process features in subfolders")
         printFlag(Some('v'), "verbose", "Adds some debug information for parse errors")
+        printFlag(None, "legacy", "Update only configured features to placed features")
     }
 
     private def printFlag(shortFlag: Option[Char], flag: String, description: String): Unit =
