Remove log

Author: tomwyr

src/main/kotlin/com/tomwyr/Command.kt

@@ -1,6 +1,5 @@
 package com.tomwyr
 
-import com.tomwyr.common.Log
 import com.tomwyr.generator.NodeTreeGenerator
 import com.tomwyr.utils.GodotKotlinProject
 import org.gradle.api.Project
@@ -9,7 +8,6 @@ class GenerateTreeCommand {
     fun run(project: Project, config: GodotNodeTreeConfig) {
         val projectPath = project.projectDir.absolutePath
         val godotProject = GodotKotlinProject.create(projectPath, config)
-        val treeInfo = NodeTreeGenerator().generate(godotProject)
-        Log.nodeTreeGenerated(treeInfo)
+        NodeTreeGenerator().generate(godotProject)
     }
 }

src/main/kotlin/com/tomwyr/Plugin.kt

@@ -1,22 +1,15 @@
 package com.tomwyr
 
-import com.tomwyr.common.Log
-import com.tomwyr.common.Logger
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
 
 class GodotNodeTree : Plugin<Project> {
     override fun apply(project: Project) {
-        initLog(project)
         registerTask(project)
         addSourceSet(project)
     }
 
-    private fun initLog(project: Project) {
-        Log.logger = Logger.stdOut(project)
-    }
-
     private fun registerTask(project: Project) {
         val config = project.extensions.create("godotNodeTree", GodotNodeTreeConfig::class.java)
         project.tasks.register("generateNodeTree") { task ->

src/main/kotlin/com/tomwyr/common/Log.kt

@@ -1,6 +1,5 @@
 package com.tomwyr.generator
 
-import com.tomwyr.common.Log
 import com.tomwyr.common.NodeTreeInfo
 import com.tomwyr.common.Scene
 import com.tomwyr.utils.GodotKotlinProject
@@ -10,22 +9,14 @@ class NodeTreeGenerator(
     private val renderer: NodeTreeRenderer = NodeTreeRenderer(),
 ) {
     fun generate(project: GodotKotlinProject): NodeTreeInfo {
-        Log.readingScenes()
         val scenesData = project.readScenes()
-        Log.scenesFound(scenesData)
-
         val scenes = scenesData.map { data ->
-            Log.parsingScene(data)
             val root = parser.parse(data)
             Scene(data.name, root)
         }.toList()
-
-        Log.renderingNodeTree()
         val content = renderer.render(project.targetPackage, scenes)
 
-        Log.savingResult()
         project.writeNodeTree(content)
-        Log.resultSaved()
 
         return NodeTreeInfo(scenes)
     }

src/main/kotlin/com/tomwyr/generator/Generator.kt

@@ -12,7 +12,6 @@ class SceneNodesParser {
 
 private class ScenesParser {
     fun parse(sceneData: SceneData): Map<String, String> {
-        Log.parsingScenePaths()
         return splitToEntries(sceneData.content, "ext_resource")
             .map(::parseEntryParams)
             .mapNotNull(::extractSceneIdToPath)
@@ -24,7 +23,6 @@ private class ScenesParser {
         val path = params["path"]
 
         if (id == null || path == null) {
-            Log.skippingSceneResource(params)
             return null
         }
 
@@ -36,17 +34,12 @@ private class ScenesParser {
             .groupBy({ it.first }, { it.second })
             .filter { it.value.size > 1 }
 
-        if (duplicates.isNotEmpty()) {
-            Log.duplicatedSceneResources(duplicates)
-        }
-
         return sceneIdsToPaths.toMap()
     }
 }
 
 private class NodesParser(val scenePathsById: Map<String, String>) {
     fun parse(sceneData: SceneData): Node {
-        Log.parsingSceneNodes()
         return splitToEntries(sceneData.content, "node")
             .map(::parseEntryParams)
             .mapNotNull(::extractNodeParams)
@@ -61,15 +54,13 @@ private class NodesParser(val scenePathsById: Map<String, String>) {
         val parent = params["parent"]
 
         if (name == null || (type == null && instance == null) || (type != null && instance != null)) {
-            Log.skippingNode(params)
             return null
         }
 
         return NodeParams(name = name, type = type, instance = instance, parent = parent)
     }
 
     private fun createRootNode(sceneName: String, params: List<NodeParams>): Node {
-        Log.creatingRootNode()
         val childrenByParent = params.groupBy { it.parent }
         val rootParams = params.firstOrNull { it.parent == null } ?: throw ParentNodeNotFound(sceneName)
         return rootParams.toNode(childrenByParent, scenePathsById)
@@ -114,13 +105,11 @@ data class NodeParams(
 }
 
 private fun splitToEntries(data: String, entryType: String): List<String> {
-    Log.splittingEntries(entryType)
     val pattern = """\[${entryType} .*]""".toRegex()
     return pattern.findAll(data).mapNotNull { it.groupValues.firstOrNull() }.toList()
 }
 
 private fun parseEntryParams(entry: String): Map<String, String> {
-    Log.parsingEntryParams(entry)
     val pattern = """(?:(\w+)=(?:\w+\("(.+)"\)|"(.+?)"))+""".toRegex()
     return pattern.findAll(entry).associate { match ->
         val (key, argumentValue, plainValue) = match.destructured
@@ -130,7 +119,6 @@ private fun parseEntryParams(entry: String): Map<String, String> {
 }
 
 private fun parseSceneName(scenePath: String): String? {
-    Log.parsingEntryParams(scenePath)
     val pattern = """^res://(.*).tscn$""".toRegex()
     return pattern.find(scenePath)?.groupValues?.getOrNull(1)
 }

src/main/kotlin/com/tomwyr/generator/Parser.kt

@@ -64,8 +64,6 @@ class NodeTreeRenderer {
             .mapIndexed { index: Int, s: String -> if (index == 0) s else s.capitalize() }
             .joinToString("")
 
-        Log.renderingNode(node, nodePath)
-
         val field = when (node) {
             is ParentNode -> """
             |val $symbolName = ${symbolName}Tree()

src/main/kotlin/com/tomwyr/generator/Renderer.kt

@@ -2,7 +2,6 @@ package com.tomwyr.utils
 
 import com.tomwyr.GodotNodeTreeConfig
 import com.tomwyr.common.InvalidGodotProject
-import com.tomwyr.common.Log
 import com.tomwyr.common.SceneData
 import java.io.File
 import java.nio.file.FileSystems
@@ -40,23 +39,10 @@ class GodotKotlinProject(
     companion object Factory {
         fun create(rootPath: String, config: GodotNodeTreeConfig): GodotKotlinProject {
             val targetPackage = config.packageName
-            if (targetPackage != null) {
-                Log.targetPackage(targetPackage)
-            }
-
-            Log.kotlinProjectPath(rootPath)
-
             val projectRelativePath = config.projectPath
-            if (projectRelativePath != null) {
-                Log.godotCustomProjectPath(projectRelativePath)
-            }
-
             val projectPath = getProjectPath(rootPath, projectRelativePath)
             projectPath ?: throw InvalidGodotProject()
-            Log.godotProjectPath(projectPath)
-
             val outputPath = getOutputPath(rootPath, targetPackage)
-            Log.kotlinOutputPath(outputPath)
 
             return GodotKotlinProject(projectPath, outputPath, targetPackage)
         }

src/main/kotlin/com/tomwyr/utils/Project.kt

@@ -34,15 +34,6 @@ class GeneratorTest {
     fun `multiple scenes`() {
         test("dodge-the-creeps", "com.example.game")
     }
-
-    @BeforeTest
-    fun setUpTestLogger() {
-        Log.logger = object : Logger {
-            override fun debug(message: String) {}
-            override fun info(message: String) {}
-            override fun warn(message: String) {}
-        }
-    }
 }
 
 fun test(testCase: String, targetPackage: String) {