Required libraries can be installed silently #492

After-review cleanup 2

Author: Vassiliy-Kudryashov

utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/util/UtProjectModelModifier.kt

@@ -2,7 +2,6 @@ package org.utbot.intellij.plugin.util
 
 import com.intellij.codeInsight.daemon.impl.quickfix.LocateLibraryDialog
 import com.intellij.codeInsight.daemon.impl.quickfix.OrderEntryFix
-import com.intellij.ide.JavaUiBundle
 import com.intellij.jarRepository.JarRepositoryManager
 import com.intellij.openapi.application.WriteAction
 import com.intellij.openapi.module.Module
@@ -14,13 +13,9 @@ import com.intellij.openapi.roots.OrderRootType
 import com.intellij.openapi.roots.impl.IdeaProjectModelModifier
 import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar
 import com.intellij.openapi.roots.libraries.LibraryUtil
-import com.intellij.openapi.roots.libraries.ui.OrderRoot
-import com.intellij.openapi.ui.Messages
 import com.intellij.util.PathUtil
 import com.intellij.util.containers.ContainerUtil
-import java.util.stream.Collectors
 import org.jetbrains.concurrency.Promise
-import org.jetbrains.concurrency.rejectedPromise
 import org.jetbrains.concurrency.resolvedPromise
 import org.jetbrains.idea.maven.utils.library.RepositoryLibraryDescription
 import org.jetbrains.idea.maven.utils.library.RepositoryLibraryProperties
@@ -31,69 +26,60 @@ class UtProjectModelModifier(val project: Project) : IdeaProjectModelModifier(pr
         modules: Collection<Module>,
         descriptor: ExternalLibraryDescriptor,
         scope: DependencyScope
-    ): Promise<Void> {
+    ): Promise<Void>? {
         val defaultRoots = descriptor.libraryClassesRoots
-        val firstModule = ContainerUtil.getFirstItem(modules) ?: return rejectedPromise()
+        val firstModule = ContainerUtil.getFirstItem(modules) ?: return null
         val classesRoots = if (defaultRoots.isNotEmpty()) {
             LocateLibraryDialog(
                 firstModule,
                 defaultRoots,
                 descriptor.presentableName
             ).showAndGetResult()
         } else {
-            val libraryProperties = RepositoryLibraryProperties(JpsMavenRepositoryLibraryDescriptor(descriptor.mavenCoordinates()))
             val roots = JarRepositoryManager.loadDependenciesModal(
                 project,
-                libraryProperties,
+                RepositoryLibraryProperties(JpsMavenRepositoryLibraryDescriptor(descriptor.mavenCoordinates())),
                 /* loadSources = */ false,
                 /* loadJavadoc = */ false,
                 /* copyTo = */ null,
                 /* repositories = */ null
             )
             if (roots.isEmpty()) {
-                @Suppress("SpellCheckingInspection")
-                Messages.showErrorDialog(
-                    project,
-                    JavaUiBundle.message("dialog.mesage.0.was.not.loaded", descriptor.presentableName),
-                    JavaUiBundle.message("dialog.title.failed.to.download.library")
-                )
-                return rejectedPromise()
+                return null
             }
-            roots.stream()
-                .filter { root: OrderRoot -> root.type === OrderRootType.CLASSES }
-                .map { root: OrderRoot ->
-                    PathUtil.getLocalPath(
-                        root.file
-                    )
-                }
-                .collect(Collectors.toList())
+            roots.filter { orderRoot -> orderRoot.type === OrderRootType.CLASSES }
+                .map { PathUtil.getLocalPath(it.file) }.toList()
         }
         if (classesRoots.isNotEmpty()) {
-            val libraryName = if (classesRoots.size > 1) descriptor.presentableName else null
             val urls = OrderEntryFix.refreshAndConvertToUrls(classesRoots)
             if (modules.size == 1) {
-                ModuleRootModificationUtil.addModuleLibrary(firstModule, libraryName, urls, emptyList(), scope)
+                ModuleRootModificationUtil.addModuleLibrary(
+                    firstModule,
+                    if (classesRoots.size > 1) descriptor.presentableName else null,
+                    urls,
+                    emptyList(),
+                    scope
+                )
             } else {
                 WriteAction.run<RuntimeException> {
-                    val library =
-                        LibraryUtil.createLibrary(
-                            LibraryTablesRegistrar.getInstance().getLibraryTable(project), descriptor.presentableName
-                        )
-                    val model = library.modifiableModel
-                    for (url in urls) {
-                        model.addRoot(url!!, OrderRootType.CLASSES)
-                    }
-                    model.commit()
-                    for (module in modules) {
-                        ModuleRootModificationUtil.addDependency(module, library, scope, false)
+                    LibraryUtil.createLibrary(
+                        LibraryTablesRegistrar.getInstance().getLibraryTable(project),
+                        descriptor.presentableName
+                    ).let {
+                        val model = it.modifiableModel
+                        urls.forEach { url -> model.addRoot(url, OrderRootType.CLASSES) }
+                        model.commit()
+                        modules.forEach { module ->
+                            ModuleRootModificationUtil.addDependency(module, it, scope, false)
+                        }
                     }
                 }
             }
         }
         return resolvedPromise()
     }
 
-    private fun ExternalLibraryDescriptor.mavenCoordinates() : String {
+    private fun ExternalLibraryDescriptor.mavenCoordinates(): String {
         return "$libraryGroupId:$libraryArtifactId:${preferredVersion ?: RepositoryLibraryDescription.ReleaseVersionId}"
     }
 }