azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ConfigLibraryUtil: J2K

Browse Source
This commit is contained in:
Dmitry Jemerov
2017-07-13 11:46:21 +02:00
parent 921db30c90
commit 060b8e0025
4 changed files with 136 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/ConfigLibraryUtil.kt
+130 -154
View File
@@ -14,218 +14,194 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.idea.test; package org.jetbrains.kotlin.idea.test
import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.module.Module; import com.intellij.openapi.module.Module
import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.projectRoots.Sdk
import com.intellij.openapi.roots.*; import com.intellij.openapi.roots.LibraryOrderEntry
import com.intellij.openapi.roots.impl.libraries.LibraryEx; import com.intellij.openapi.roots.ModifiableRootModel
import com.intellij.openapi.roots.libraries.Library; import com.intellij.openapi.roots.ModuleRootManager
import com.intellij.openapi.roots.ui.configuration.libraryEditor.NewLibraryEditor; import com.intellij.openapi.roots.OrderRootType
import com.intellij.openapi.util.Computable; import com.intellij.openapi.roots.impl.libraries.LibraryEx
import com.intellij.openapi.vfs.VfsUtil; import com.intellij.openapi.roots.libraries.Library
import kotlin.jvm.functions.Function0; import com.intellij.openapi.roots.ui.configuration.libraryEditor.NewLibraryEditor
import org.jetbrains.annotations.NotNull; import com.intellij.openapi.util.Computable
import org.jetbrains.kotlin.idea.util.application.ApplicationUtilsKt; import com.intellij.openapi.vfs.VfsUtil
import org.jetbrains.kotlin.test.InTextDirectivesUtils; import org.jetbrains.kotlin.idea.util.application.runWriteAction
import org.jetbrains.kotlin.utils.PathUtil; import org.jetbrains.kotlin.test.InTextDirectivesUtils
import org.jetbrains.kotlin.utils.PathUtil
import java.io.File; import java.io.File
import java.util.ArrayList; import java.util.*
import java.util.Iterator;
import java.util.List;
/** /**
* Helper for configuring kotlin runtime in tested project. * Helper for configuring kotlin runtime in tested project.
*/ */
public class ConfigLibraryUtil { object ConfigLibraryUtil {
private static final String DEFAULT_JAVA_RUNTIME_LIB_NAME = "JAVA_RUNTIME_LIB_NAME"; private val DEFAULT_JAVA_RUNTIME_LIB_NAME = "JAVA_RUNTIME_LIB_NAME"
private static final String DEFAULT_KOTLIN_TEST_LIB_NAME = "KOTLIN_TEST_LIB_NAME"; private val DEFAULT_KOTLIN_TEST_LIB_NAME = "KOTLIN_TEST_LIB_NAME"
private static final String DEFAULT_KOTLIN_JS_STDLIB_NAME = "KOTLIN_JS_STDLIB_NAME"; private val DEFAULT_KOTLIN_JS_STDLIB_NAME = "KOTLIN_JS_STDLIB_NAME"
private ConfigLibraryUtil() { private fun getKotlinRuntimeLibEditor(libName: String, library: File): NewLibraryEditor {
val editor = NewLibraryEditor()
editor.name = libName
editor.addRoot(VfsUtil.getUrlForLibraryRoot(library), OrderRootType.CLASSES)
return editor
} }
private static NewLibraryEditor getKotlinRuntimeLibEditor(String libName, File library) { fun configureKotlinRuntimeAndSdk(module: Module, sdk: Sdk) {
NewLibraryEditor editor = new NewLibraryEditor(); configureSdk(module, sdk)
editor.setName(libName); configureKotlinRuntime(module)
editor.addRoot(VfsUtil.getUrlForLibraryRoot(library), OrderRootType.CLASSES);
return editor;
} }
public static void configureKotlinRuntimeAndSdk(Module module, Sdk sdk) { fun configureKotlinJsRuntimeAndSdk(module: Module, sdk: Sdk) {
configureSdk(module, sdk); configureSdk(module, sdk)
configureKotlinRuntime(module);
}
public static void configureKotlinJsRuntimeAndSdk(Module module, Sdk sdk) {
configureSdk(module, sdk);
addLibrary(getKotlinRuntimeLibEditor(DEFAULT_KOTLIN_JS_STDLIB_NAME, addLibrary(getKotlinRuntimeLibEditor(DEFAULT_KOTLIN_JS_STDLIB_NAME,
PathUtil.getKotlinPathsForDistDirectory().getJsStdLibJarPath()), module); PathUtil.getKotlinPathsForDistDirectory().jsStdLibJarPath), module)
} }
public static void configureKotlinRuntime(Module module) { fun configureKotlinRuntime(module: Module) {
addLibrary(getKotlinRuntimeLibEditor(DEFAULT_JAVA_RUNTIME_LIB_NAME, PathUtil.getKotlinPathsForDistDirectory().getStdlibPath()), addLibrary(getKotlinRuntimeLibEditor(DEFAULT_JAVA_RUNTIME_LIB_NAME, PathUtil.getKotlinPathsForDistDirectory().stdlibPath),
module); module)
addLibrary(getKotlinRuntimeLibEditor(DEFAULT_KOTLIN_TEST_LIB_NAME, PathUtil.getKotlinPathsForDistDirectory().getKotlinTestPath()), addLibrary(getKotlinRuntimeLibEditor(DEFAULT_KOTLIN_TEST_LIB_NAME, PathUtil.getKotlinPathsForDistDirectory().kotlinTestPath),
module); module)
} }
public static void unConfigureKotlinRuntime(Module module) { fun unConfigureKotlinRuntime(module: Module) {
removeLibrary(module, DEFAULT_JAVA_RUNTIME_LIB_NAME); removeLibrary(module, DEFAULT_JAVA_RUNTIME_LIB_NAME)
removeLibrary(module, DEFAULT_KOTLIN_TEST_LIB_NAME); removeLibrary(module, DEFAULT_KOTLIN_TEST_LIB_NAME)
} }
public static void unConfigureKotlinRuntimeAndSdk(Module module, Sdk sdk) { fun unConfigureKotlinRuntimeAndSdk(module: Module, sdk: Sdk) {
configureSdk(module, sdk); configureSdk(module, sdk)
unConfigureKotlinRuntime(module); unConfigureKotlinRuntime(module)
} }
public static void unConfigureKotlinJsRuntimeAndSdk(Module module, Sdk sdk) { fun unConfigureKotlinJsRuntimeAndSdk(module: Module, sdk: Sdk) {
configureSdk(module, sdk); configureSdk(module, sdk)
removeLibrary(module, DEFAULT_KOTLIN_JS_STDLIB_NAME); removeLibrary(module, DEFAULT_KOTLIN_JS_STDLIB_NAME)
} }
public static void configureSdk(@NotNull final Module module, @NotNull final Sdk sdk) { fun configureSdk(module: Module, sdk: Sdk) {
ApplicationManager.getApplication().runWriteAction(new Runnable() { ApplicationManager.getApplication().runWriteAction {
@Override val rootManager = ModuleRootManager.getInstance(module)
public void run() { val rootModel = rootManager.modifiableModel
ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
ModifiableRootModel rootModel = rootManager.getModifiableModel();
rootModel.setSdk(sdk); rootModel.sdk = sdk
rootModel.commit(); rootModel.commit()
} }
});
} }
public static Library addLibrary(final NewLibraryEditor editor, final Module module) { fun addLibrary(editor: NewLibraryEditor, module: Module): Library {
return ApplicationManager.getApplication().runWriteAction(new Computable<Library>() { return ApplicationManager.getApplication().runWriteAction(Computable {
@Override val rootManager = ModuleRootManager.getInstance(module)
public Library compute() { val model = rootManager.modifiableModel
ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
ModifiableRootModel model = rootManager.getModifiableModel();
Library library = addLibrary(editor, model); val library = addLibrary(editor, model)
model.commit(); model.commit()
return library; library
} })
});
} }
public static Library addLibrary(NewLibraryEditor editor, ModifiableRootModel model) { fun addLibrary(editor: NewLibraryEditor, model: ModifiableRootModel): Library {
Library library = model.getModuleLibraryTable().createLibrary(editor.getName()); val library = model.moduleLibraryTable.createLibrary(editor.name)
Library.ModifiableModel libModel = library.getModifiableModel(); val libModel = library.modifiableModel
editor.applyTo((LibraryEx.ModifiableModelEx) libModel); editor.applyTo(libModel as LibraryEx.ModifiableModelEx)
libModel.commit(); libModel.commit()
return library; return library
} }
public static boolean removeLibrary(@NotNull final Module module, @NotNull final String libraryName) { fun removeLibrary(module: Module, libraryName: String): Boolean {
return ApplicationUtilsKt.runWriteAction( return runWriteAction {
new Function0<Boolean>() { var removed = false
@Override
public Boolean invoke() {
boolean removed = false;
ModuleRootManager rootManager = ModuleRootManager.getInstance(module); val rootManager = ModuleRootManager.getInstance(module)
ModifiableRootModel model = rootManager.getModifiableModel(); val model = rootManager.modifiableModel
for (OrderEntry orderEntry : model.getOrderEntries()) { for (orderEntry in model.orderEntries) {
if (orderEntry instanceof LibraryOrderEntry) { if (orderEntry is LibraryOrderEntry) {
LibraryOrderEntry libraryOrderEntry = (LibraryOrderEntry) orderEntry;
Library library = libraryOrderEntry.getLibrary(); val library = orderEntry.library
if (library != null) { if (library != null) {
String name = library.getName(); val name = library.name
if (name != null && name.equals(libraryName)) { if (name != null && name == libraryName) {
// Dispose attached roots // Dispose attached roots
Library.ModifiableModel modifiableModel = library.getModifiableModel(); val modifiableModel = library.modifiableModel
for (String rootUrl : library.getRootProvider().getUrls(OrderRootType.CLASSES)) { for (rootUrl in library.rootProvider.getUrls(OrderRootType.CLASSES)) {
modifiableModel.removeRoot(rootUrl, OrderRootType.CLASSES); modifiableModel.removeRoot(rootUrl, OrderRootType.CLASSES)
}
for (String rootUrl : library.getRootProvider().getUrls(OrderRootType.SOURCES)) {
modifiableModel.removeRoot(rootUrl, OrderRootType.SOURCES);
}
modifiableModel.commit();
model.getModuleLibraryTable().removeLibrary(library);
removed = true;
break;
}
}
} }
for (rootUrl in library.rootProvider.getUrls(OrderRootType.SOURCES)) {
modifiableModel.removeRoot(rootUrl, OrderRootType.SOURCES)
}
modifiableModel.commit()
model.moduleLibraryTable.removeLibrary(library)
removed = true
break
} }
model.commit();
return removed;
} }
} }
); }
}
public static void addLibrary(@NotNull Module module, @NotNull String libraryName, @NotNull String rootPath, @NotNull String[] jarPaths) { model.commit()
NewLibraryEditor editor = new NewLibraryEditor();
editor.setName(libraryName);
for (String jarPath : jarPaths) {
editor.addRoot(VfsUtil.getUrlForLibraryRoot(new File(rootPath, jarPath)), OrderRootType.CLASSES);
}
addLibrary(editor, module); removed
}
public static void configureLibraries(@NotNull Module module, String rootPath, List<String> libraryInfos) {
for (String libraryInfo : libraryInfos) {
int i = libraryInfo.indexOf('@');
String libraryName = libraryInfo.substring(0, i);
String[] jarPaths = libraryInfo.substring(i + 1).split(";");
addLibrary(module, libraryName, rootPath, jarPaths);
} }
} }
public static void unconfigureLibrariesByName(@NotNull Module module, List<String> libraryNames) { fun addLibrary(module: Module, libraryName: String, rootPath: String, jarPaths: Array<String>) {
for (Iterator<String> iterator = libraryNames.iterator(); iterator.hasNext(); ) { val editor = NewLibraryEditor()
String libraryName = iterator.next(); editor.name = libraryName
for (jarPath in jarPaths) {
editor.addRoot(VfsUtil.getUrlForLibraryRoot(File(rootPath, jarPath)), OrderRootType.CLASSES)
}
addLibrary(editor, module)
}
fun configureLibraries(module: Module, rootPath: String, libraryInfos: List<String>) {
for (libraryInfo in libraryInfos) {
val i = libraryInfo.indexOf('@')
val libraryName = libraryInfo.substring(0, i)
val jarPaths = libraryInfo.substring(i + 1).split(";".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
addLibrary(module, libraryName, rootPath, jarPaths)
}
}
fun unconfigureLibrariesByName(module: Module, libraryNames: MutableList<String>) {
val iterator = libraryNames.iterator()
while (iterator.hasNext()) {
val libraryName = iterator.next()
if (removeLibrary(module, libraryName)) { if (removeLibrary(module, libraryName)) {
iterator.remove(); iterator.remove()
} }
} }
if (!libraryNames.isEmpty()) throw new AssertionError("Couldn't find the following libraries: " + libraryNames); if (!libraryNames.isEmpty()) throw AssertionError("Couldn't find the following libraries: " + libraryNames)
} }
public static void unconfigureLibrariesByInfo(@NotNull Module module, List<String> libraryInfos) { fun configureLibrariesByDirective(module: Module, rootPath: String, fileText: String) {
List<String> libraryNames = new ArrayList<String>(); configureLibraries(module, rootPath, InTextDirectivesUtils.findListWithPrefixes(fileText, "// CONFIGURE_LIBRARY: "))
for (String libraryInfo : libraryInfos) {
libraryNames.add(libraryInfo.substring(0, libraryInfo.indexOf('@')));
}
unconfigureLibrariesByName(module, libraryNames);
} }
public static void configureLibrariesByDirective(@NotNull Module module, String rootPath, String fileText) { fun unconfigureLibrariesByDirective(module: Module, fileText: String) {
configureLibraries(module, rootPath, InTextDirectivesUtils.findListWithPrefixes(fileText, "// CONFIGURE_LIBRARY: ")); val libraryNames = ArrayList<String>()
} for (libInfo in InTextDirectivesUtils.findListWithPrefixes(fileText, "// CONFIGURE_LIBRARY: ")) {
libraryNames.add(libInfo.substring(0, libInfo.indexOf('@')))
public static void unconfigureLibrariesByDirective(@NotNull Module module, String fileText) {
List<String> libraryNames = new ArrayList<String>();
for (String libInfo : InTextDirectivesUtils.findListWithPrefixes(fileText, "// CONFIGURE_LIBRARY: ")) {
libraryNames.add(libInfo.substring(0, libInfo.indexOf('@')));
} }
for (String libraryName : InTextDirectivesUtils.findListWithPrefixes(fileText, "// UNCONFIGURE_LIBRARY: ")) { for (libraryName in InTextDirectivesUtils.findListWithPrefixes(fileText, "// UNCONFIGURE_LIBRARY: ")) {
libraryNames.add(libraryName); libraryNames.add(libraryName)
} }
unconfigureLibrariesByName(module, libraryNames); unconfigureLibrariesByName(module, libraryNames)
} }
} }
idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinCheckerTest.java
+1 -1
View File
@@ -100,7 +100,7 @@ public abstract class AbstractJavaAgainstKotlinCheckerTest extends KotlinDaemonA
} }
if (InTextDirectivesUtils.isDirectiveDefined(configFileText, "// WITH_RUNTIME")) { if (InTextDirectivesUtils.isDirectiveDefined(configFileText, "// WITH_RUNTIME")) {
ConfigLibraryUtil.configureKotlinRuntime(module); ConfigLibraryUtil.INSTANCE.configureKotlinRuntime(module);
} }
List<String> languageLevelLines = InTextDirectivesUtils.findLinesWithPrefixesRemoved(configFileText, "// LANGUAGE_LEVEL"); List<String> languageLevelLines = InTextDirectivesUtils.findLinesWithPrefixesRemoved(configFileText, "// LANGUAGE_LEVEL");
idea/tests/org/jetbrains/kotlin/idea/KotlinHierarchyViewTestBase.java
+2 -2
View File
@@ -26,12 +26,12 @@ public abstract class KotlinHierarchyViewTestBase extends HierarchyViewTestBase
protected void setUp() throws Exception { protected void setUp() throws Exception {
VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory()); VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory());
super.setUp(); super.setUp();
ConfigLibraryUtil.configureKotlinRuntime(myModule); ConfigLibraryUtil.INSTANCE.configureKotlinRuntime(myModule);
} }
@Override @Override
protected void tearDown() throws Exception { protected void tearDown() throws Exception {
ConfigLibraryUtil.unConfigureKotlinRuntime(myModule); ConfigLibraryUtil.INSTANCE.unConfigureKotlinRuntime(myModule);
super.tearDown(); super.tearDown();
VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory()); VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory());
} }
idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java
+3 -3
View File
@@ -205,7 +205,7 @@ public abstract class KotlinDebuggerTestCase extends DescriptorTestCase {
customLibEditor.addRoot(VfsUtil.getUrlForLibraryRoot(classes), OrderRootType.CLASSES); customLibEditor.addRoot(VfsUtil.getUrlForLibraryRoot(classes), OrderRootType.CLASSES);
customLibEditor.addRoot(VfsUtil.getUrlForLibraryRoot(sources), OrderRootType.SOURCES); customLibEditor.addRoot(VfsUtil.getUrlForLibraryRoot(sources), OrderRootType.SOURCES);
ConfigLibraryUtil.addLibrary(customLibEditor, model); ConfigLibraryUtil.INSTANCE.addLibrary(customLibEditor, model);
} }
@Override @Override
@@ -215,8 +215,8 @@ public abstract class KotlinDebuggerTestCase extends DescriptorTestCase {
} }
EdtTestUtil.runInEdtAndWait(() -> { EdtTestUtil.runInEdtAndWait(() -> {
ConfigLibraryUtil.removeLibrary(getModule(), CUSTOM_LIBRARY_NAME); ConfigLibraryUtil.INSTANCE.removeLibrary(getModule(), CUSTOM_LIBRARY_NAME);
ConfigLibraryUtil.removeLibrary(getModule(), KOTLIN_LIBRARY_NAME); ConfigLibraryUtil.INSTANCE.removeLibrary(getModule(), KOTLIN_LIBRARY_NAME);
}); });
super.tearDown(); super.tearDown();