Some pre-merge refactoring

Author: EgorkaKulikov

utbot-spring-analyzer/src/main/kotlin/ApplicationRunner.kt

@@ -1,13 +1,19 @@
 package application
 
 import analyzers.SpringApplicationAnalyzer
+import utils.PathsUtils
 
+/**
+ * To run this app, arguments must be passed in the following way:
+ * args[0] - classpath of current project
+ * args[1] - fully qualified name of configuration class
+ * args[2] - `.properties` file paths, separated via `;`, empty string if no files exist
+ * args[3] - `.xml` configuration file paths
+ *
+ * Several items in one arg are separated via `;`.
+ * If there are no files, empty string should be passed.
+ */
 fun main(args: Array<String>) {
-    /*
-        arg2 contains .properties files, arg3 contains .xml files.
-        If there are several files, they are transmitted via ";".
-        If there are no files, then an empty string "" is passed
-    */
 
     /* FOR EXAMPLE
     val arg0 = "/Users/kirillshishin/IdeaProjects/spring-starter-lesson-28/build/classes/java/main"
@@ -19,8 +25,8 @@ fun main(args: Array<String>) {
     val springApplicationAnalyzer = SpringApplicationAnalyzer(
         applicationPath = args[0],
         configurationClassFqn = args[1],
-        propertyFilesPaths = args[2].split(";"),
-        xmlConfigurationPaths = args[3].split(";"),
+        propertyFilesPaths = args[2].split(";").filter { it != PathsUtils.EMPTY_PATH },
+        xmlConfigurationPaths = args[3].split(";").filter { it != PathsUtils.EMPTY_PATH },
     )
 
     springApplicationAnalyzer.analyze()

utbot-spring-analyzer/src/main/kotlin/analyzers/SpringApplicationAnalyzer.kt

@@ -31,7 +31,7 @@ class SpringApplicationAnalyzer(
 
         val configurationManager = ConfigurationManager(classLoader, userConfigurationClass)
         val propertiesConfigurator = PropertiesConfigurator(propertyFilesPaths, configurationManager)
-        val xmlFilesConfigurator = XmlFilesConfigurator(xmlConfigurationPaths, configurationManager, fakeFileManager)
+        val xmlFilesConfigurator = XmlFilesConfigurator(xmlConfigurationPaths, configurationManager)
 
         propertiesConfigurator.configure()
         xmlFilesConfigurator.configure()

utbot-spring-analyzer/src/main/kotlin/configurators/PropertiesConfigurator.kt

@@ -1,7 +1,7 @@
 package application.configurators
 
 import utils.ConfigurationManager
-import utils.Paths
+import utils.PathsUtils
 import java.io.BufferedReader
 import java.io.FileReader
 import kotlin.io.path.Path
@@ -11,21 +11,19 @@ class PropertiesConfigurator(
     private val configurationManager: ConfigurationManager
 ) {
 
-    fun configure(){
+    fun configure() {
         configurationManager.clearPropertySourceAnnotation()
 
-        for(propertiesFilePath in propertiesFilesPaths) {
-            if(propertiesFilePath == Paths.EMPTY_PATH)continue
-
-            configurationManager.patchPropertySourceAnnotation(Path(propertiesFilePath).fileName)
-        }
+        propertiesFilesPaths
+            .map { Path(it).fileName }
+            .forEach { fileName -> configurationManager.patchPropertySourceAnnotation(fileName) }
     }
 
     fun readProperties(): ArrayList<String> {
         val props = ArrayList<String>()
 
-        for(propertiesFilePath in propertiesFilesPaths) {
-            if(propertiesFilePath == Paths.EMPTY_PATH)continue
+        for (propertiesFilePath in propertiesFilesPaths) {
+            if (propertiesFilePath == PathsUtils.EMPTY_PATH) continue
 
             val reader = BufferedReader(FileReader(propertiesFilePath))
             var line = reader.readLine()

utbot-spring-analyzer/src/main/kotlin/configurators/XmlFilesConfigurator.kt

@@ -3,23 +3,22 @@ package application.configurators
 import analyzers.XmlConfigurationAnalyzer
 import application.utils.FakeFileManager
 import utils.ConfigurationManager
-import utils.Paths
+import utils.PathsUtils
 import kotlin.io.path.Path
 
 class XmlFilesConfigurator(
     private val userXmlFilePaths: List<String>,
     private val configurationManager: ConfigurationManager,
-    private val fakeFileManager: FakeFileManager
 ) {
 
     fun configure() {
         configurationManager.clearImportResourceAnnotation()
 
         for (userXmlFilePath in userXmlFilePaths) {
-            if(userXmlFilePath == Paths.EMPTY_PATH)continue
+            if(userXmlFilePath == PathsUtils.EMPTY_PATH)continue
 
             val xmlConfigurationAnalyzer =
-                XmlConfigurationAnalyzer(userXmlFilePath, fakeFileManager.getFakeFilePath(userXmlFilePath))
+                XmlConfigurationAnalyzer(userXmlFilePath, PathsUtils.createFakeFilePath(userXmlFilePath))
 
             xmlConfigurationAnalyzer.fillFakeApplicationXml()
             configurationManager.patchImportResourceAnnotation(Path(userXmlFilePath).fileName)

utbot-spring-analyzer/src/main/kotlin/post_processors/UtBotBeanFactoryPostProcessor.kt

@@ -1,6 +1,5 @@
 package post_processors
 
-import org.springframework.beans.BeansException
 import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition
 import org.springframework.beans.factory.config.BeanFactoryPostProcessor
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory
@@ -13,9 +12,26 @@ import java.util.Arrays
 
 class UtBotBeanFactoryPostProcessor : BeanFactoryPostProcessor, PriorityOrdered {
 
+    /**
+     * Sets the priority of post processor to highest to avoid side effects from others.
+     */
+    override fun getOrder(): Int = PriorityOrdered.HIGHEST_PRECEDENCE
+
     override fun postProcessBeanFactory(beanFactory: ConfigurableListableBeanFactory) {
         println("Started post-processing bean factory in UtBot")
 
+        val beanClassNames = findBeanClassNames(beanFactory)
+        //TODO: will be replaced with more appropriate IPC approach.
+        writeToFile(beanClassNames)
+
+        // After desired post-processing is completed we destroy bean definitions
+        // to avoid further possible actions with beans that may be unsafe.
+        destroyBeanDefinitions(beanFactory)
+
+        println("Finished post-processing bean factory in UtBot")
+    }
+
+    private fun findBeanClassNames(beanFactory: ConfigurableListableBeanFactory): ArrayList<String> {
         val beanClassNames = ArrayList<String>()
         for (beanDefinitionName in beanFactory.beanDefinitionNames) {
             val beanDefinition = beanFactory.getBeanDefinition(beanDefinitionName)
@@ -33,12 +49,15 @@ class UtBotBeanFactoryPostProcessor : BeanFactoryPostProcessor, PriorityOrdered
                 className?.let { beanClassNames.add(it) }
             }
         }
+
+        return beanClassNames
+    }
+
+    private fun destroyBeanDefinitions(beanFactory: ConfigurableListableBeanFactory) {
         for (beanDefinitionName in beanFactory.beanDefinitionNames) {
             val beanRegistry = beanFactory as BeanDefinitionRegistry
             beanRegistry.removeBeanDefinition(beanDefinitionName)
         }
-
-        writeToFile(beanClassNames)
     }
 
     private fun writeToFile(beanClassNames: ArrayList<String>) {
@@ -58,14 +77,10 @@ class UtBotBeanFactoryPostProcessor : BeanFactoryPostProcessor, PriorityOrdered
 
             fileWriter.flush()
             fileWriter.close()
+
+            println("Storing bean information completed successfully")
         } catch (e: Throwable) {
-            println("Storing bean information failed")
-        } finally {
-            println("Finished post-processing bean factory in UtBot")
+            println("Storing bean information failed with exception $e")
         }
     }
-
-    override fun getOrder(): Int {
-        return PriorityOrdered.HIGHEST_PRECEDENCE
-    }
 }

utbot-spring-analyzer/src/main/kotlin/utils/ConfigurationManager.kt

@@ -9,32 +9,15 @@ import kotlin.reflect.KClass
 
 class ConfigurationManager(private val classLoader: ClassLoader, private val userConfigurationClass: Class<*>) {
 
-    fun clearPropertySourceAnnotation(){
-        patchAnnotation(
-            PropertySource::class, null
-        )
-    }
+    fun clearPropertySourceAnnotation() = patchAnnotation(PropertySource::class, null)
 
-    fun clearImportResourceAnnotation(){
-        patchAnnotation(
-            ImportResource::class, null
-        )
-    }
+    fun clearImportResourceAnnotation() = patchAnnotation(ImportResource::class, null)
 
     fun patchPropertySourceAnnotation(userPropertiesFileName: Path) =
-        patchAnnotation(
-            PropertySource::class, String.format(
-                "classpath:%s", "fake_$userPropertiesFileName"
-            )
-        )
+        patchAnnotation(PropertySource::class, String.format("classpath:%s", "fake_$userPropertiesFileName"))
 
     fun patchImportResourceAnnotation(userXmlFilePath: Path) =
-        patchAnnotation(
-            ImportResource::class,
-            String.format(
-                "classpath:%s", "fake_$userXmlFilePath"
-            )
-        )
+        patchAnnotation(ImportResource::class, String.format("classpath:%s", "fake_$userXmlFilePath"))
 
     private fun patchAnnotation(annotationClass: KClass<*>, newValue: String?) {
         val proxyClass = classLoader.loadClass("java.lang.reflect.Proxy")

utbot-spring-analyzer/src/main/kotlin/utils/FakeFileManager.kt

@@ -1,31 +1,34 @@
 package application.utils
 
-import utils.Paths
+import utils.PathsUtils
 import java.io.File
-import kotlin.io.path.Path
+import java.io.IOException
 
 class FakeFileManager(private val fakeFilesList: List<String>) {
 
-    private val buildResourcesPath =
-        Path(this.javaClass.classLoader.getResource(Paths.GAG_FILE)!!.path).parent.toString()
-
     fun createFakeFiles() {
         for (fileName in fakeFilesList) {
-            if(fileName == Paths.EMPTY_FILENAME)continue
-            val fakeXmlFileAbsolutePath = getFakeFilePath(fileName)
-            File(fakeXmlFileAbsolutePath).createNewFile()
+            val fakeXmlFileAbsolutePath = PathsUtils.createFakeFilePath(fileName)
+
+            try {
+                File(fakeXmlFileAbsolutePath).createNewFile()
+            } catch (e: IOException) {
+                println("Fake xml file creation failed with exception $e")
+            }
+
         }
     }
 
     fun deleteFakeFiles() {
         for (fileName in fakeFilesList) {
-            if(fileName == Paths.EMPTY_FILENAME)continue
-            val fakeXmlFileAbsolutePath = getFakeFilePath(fileName)
-            File(fakeXmlFileAbsolutePath).delete()
-        }
-    }
+            val fakeXmlFileAbsolutePath = PathsUtils.createFakeFilePath(fileName)
+
+            try {
+                File(fakeXmlFileAbsolutePath).delete()
+            } catch (e: IOException) {
+                println("Fake xml file deletion failed with exception $e")
+            }
 
-    fun getFakeFilePath(fileName: String): String {
-        return Path(buildResourcesPath, "fake_${Path(fileName).fileName}").toString()
+        }
     }
 }

utbot-spring-analyzer/src/main/kotlin/utils/Paths.kt

@@ -0,0 +1,21 @@
+package utils
+
+import kotlin.io.path.Path
+
+object PathsUtils {
+    const val EMPTY_PATH = ""
+
+    fun createFakeFilePath(fileName: String): String =
+        Path(buildResourcesPath, "fake_${Path(fileName).fileName}").toString()
+
+    //TODO: it is better to do it without marker files
+    private val buildResourcesPath: String
+        get() {
+            val resourcesMarker =
+                this.javaClass.classLoader.getResource("resources_marker.txt")
+                    ?: error("Resources marker file is not found")
+
+            return Path(resourcesMarker.path).parent.toString()
+        }
+
+}

utbot-spring-analyzer/src/main/kotlin/utils/PathsUtils.kt

@@ -0,0 +1 @@
+DO NOT DELETE THIS FILE!!!