MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-03-22 06:50:54 +07:00
Code Issues Packages Projects Releases Wiki Activity

ApplicationConfigurationProducer converted to new API

Browse Source
This commit is contained in:
Dmitry Jemerov
2013-08-01 13:30:04 +02:00
parent a80b978c56
commit db3b6c6914
5 changed files with 101 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
java/execution/impl/src/com/intellij/execution/application/ApplicationConfigurationProducer.java
View File

@@ -15,101 +15,89 @@
*/
package com.intellij.execution.application;
import com.intellij.execution.*;
import com.intellij.execution.JavaExecutionUtil;
import com.intellij.execution.JavaRunConfigurationExtensionManager;
import com.intellij.execution.Location;
import com.intellij.execution.actions.ConfigurationContext;
import com.intellij.execution.configurations.ConfigurationUtil;
import com.intellij.execution.impl.RunManagerImpl;
import com.intellij.execution.junit.JavaRuntimeConfigurationProducerBase;
import com.intellij.execution.junit.RuntimeConfigurationProducer;
import com.intellij.execution.junit.JavaRunConfigurationProducerBase;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Comparing;
import com.intellij.openapi.util.Ref;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.util.PsiMethodUtil;
import org.jetbrains.annotations.NotNull;
import com.intellij.psi.util.PsiTreeUtil;
import org.jetbrains.annotations.Nullable;
public class ApplicationConfigurationProducer extends JavaRuntimeConfigurationProducerBase implements Cloneable {
private PsiElement myPsiElement = null;
public static final RuntimeConfigurationProducer PROTOTYPE = new ApplicationConfigurationProducer();
public class ApplicationConfigurationProducer extends JavaRunConfigurationProducerBase<ApplicationConfiguration> {
public ApplicationConfigurationProducer() {
super(ApplicationConfigurationType.getInstance());
}
public PsiElement getSourceElement() {
return myPsiElement;
}
public RunnerAndConfigurationSettings createConfigurationByElement(Location location, final ConfigurationContext context) {
location = JavaExecutionUtil.stepIntoSingleClass(location);
if (location == null) return null;
@Override
protected boolean setupConfigurationFromContext(ApplicationConfiguration configuration,
ConfigurationContext context,
Ref<PsiElement> sourceElement) {
Location location = JavaExecutionUtil.stepIntoSingleClass(context.getLocation());
if (location == null) return false;
final PsiElement element = location.getPsiElement();
if (!element.isPhysical()) return null;
if (!element.isPhysical()) return false;
PsiElement currentElement = element;
PsiMethod method;
while ((method = findMain(currentElement)) != null) {
final PsiClass aClass = method.getContainingClass();
if (ConfigurationUtil.MAIN_CLASS.value(aClass)) {
myPsiElement = method;
return createConfiguration(aClass, context, location);
sourceElement.set(method);
setupConfiguration(configuration, aClass, context, location);
return true;
}
currentElement = method.getParent();
}
final PsiClass aClass = ApplicationConfigurationType.getMainClass(element);
if (aClass == null) return null;
myPsiElement = aClass;
return createConfiguration(aClass, context, location);
if (aClass == null) return false;
sourceElement.set(aClass);
setupConfiguration(configuration, aClass, context, location);
return true;
}
private RunnerAndConfigurationSettings createConfiguration(final PsiClass aClass, final ConfigurationContext context, Location location) {
final Project project = aClass.getProject();
RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(project, context);
final ApplicationConfiguration configuration = (ApplicationConfiguration)settings.getConfiguration();
private void setupConfiguration(ApplicationConfiguration configuration,
final PsiClass aClass,
final ConfigurationContext context,
Location location) {
configuration.MAIN_CLASS_NAME = JavaExecutionUtil.getRuntimeQualifiedName(aClass);
configuration.setGeneratedName();
setupConfigurationModule(context, configuration);
JavaRunConfigurationExtensionManager.getInstance().extendCreatedConfiguration(configuration, location);
return settings;
}
@Nullable
private static PsiMethod findMain(PsiElement element) {
PsiMethod method;
while ((method = getContainingMethod(element)) != null)
while ((method = PsiTreeUtil.getParentOfType(element, PsiMethod.class)) != null) {
if (PsiMethodUtil.isMainMethod(method)) return method;
else element = method.getParent();
}
return null;
}
public int compareTo(final Object o) {
return PREFERED;
}
@Override
protected RunnerAndConfigurationSettings findExistingByElement(Location location,
@NotNull RunnerAndConfigurationSettings[] existingConfigurations,
ConfigurationContext context) {
final PsiClass aClass = ApplicationConfigurationType.getMainClass(location.getPsiElement());
if (aClass == null) {
return null;
}
final Module predefinedModule =
((ApplicationConfiguration)((RunManagerImpl)RunManagerEx.getInstanceEx(location.getProject()))
public boolean isConfigurationFromContext(ApplicationConfiguration appConfiguration, ConfigurationContext context) {
final PsiClass aClass = ApplicationConfigurationType.getMainClass(context.getPsiLocation());
if (aClass != null && Comparing.equal(JavaExecutionUtil.getRuntimeQualifiedName(aClass), appConfiguration.MAIN_CLASS_NAME)) {
final Module configurationModule = appConfiguration.getConfigurationModule().getModule();
if (Comparing.equal(context.getModule(), configurationModule)) return true;
ApplicationConfiguration template = (ApplicationConfiguration)context.getRunManager()
.getConfigurationTemplate(getConfigurationFactory())
.getConfiguration()).getConfigurationModule().getModule();
for (RunnerAndConfigurationSettings existingConfiguration : existingConfigurations) {
final ApplicationConfiguration appConfiguration = (ApplicationConfiguration)existingConfiguration.getConfiguration();
if (Comparing.equal(JavaExecutionUtil.getRuntimeQualifiedName(aClass), appConfiguration.MAIN_CLASS_NAME)) {
final Module configurationModule = appConfiguration.getConfigurationModule().getModule();
if (Comparing.equal(location.getModule(), configurationModule)) return existingConfiguration;
if (Comparing.equal(predefinedModule, configurationModule)) {
return existingConfiguration;
}
.getConfiguration();
final Module predefinedModule = template.getConfigurationModule().getModule();
if (Comparing.equal(predefinedModule, configurationModule)) {
return true;
}
}
return null;
return false;
}
}

49
java/execution/impl/src/com/intellij/execution/junit/JavaRunConfigurationProducerBase.java Normal file
View File

@@ -0,0 +1,49 @@
package com.intellij.execution.junit;
import com.intellij.execution.RunnerAndConfigurationSettings;
import com.intellij.execution.actions.ConfigurationContext;
import com.intellij.execution.actions.RunConfigurationProducer;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.ConfigurationType;
import com.intellij.execution.configurations.ModuleBasedConfiguration;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.openapi.module.Module;
import org.jetbrains.annotations.Nullable;
/**
* @author yole
*/
public abstract class JavaRunConfigurationProducerBase<T extends RunConfiguration> extends RunConfigurationProducer<T> {
protected JavaRunConfigurationProducerBase(ConfigurationFactory configurationFactory) {
super(configurationFactory);
}
protected JavaRunConfigurationProducerBase(ConfigurationType configurationType) {
super(configurationType);
}
protected boolean setupConfigurationModule(@Nullable ConfigurationContext context, ModuleBasedConfiguration configuration) {
if (context != null) {
final RunnerAndConfigurationSettings template = context.getRunManager().getConfigurationTemplate(getConfigurationFactory());
final Module contextModule = context.getModule();
final Module predefinedModule = ((ModuleBasedConfiguration)template.getConfiguration()).getConfigurationModule().getModule();
if (predefinedModule != null) {
configuration.setModule(predefinedModule);
return true;
}
final Module module = findModule(configuration, contextModule);
if (module != null) {
configuration.setModule(module);
return true;
}
}
return false;
}
protected Module findModule(ModuleBasedConfiguration configuration, Module contextModule) {
if (configuration.getConfigurationModule().getModule() == null && contextModule != null) {
return contextModule;
}
return null;
}
}

12
platform/lang-api/src/com/intellij/execution/actions/RunConfigurationProducer.java
View File

@@ -23,6 +23,7 @@ import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.ConfigurationType;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.openapi.util.Ref;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -44,6 +45,10 @@ public abstract class RunConfigurationProducer<T extends RunConfiguration> {
myConfigurationFactory = configurationType.getConfigurationFactories()[0];
}
public ConfigurationFactory getConfigurationFactory() {
return myConfigurationFactory;
}
public ConfigurationType getConfigurationType() {
return myConfigurationFactory.getType();
}
@@ -51,13 +56,14 @@ public abstract class RunConfigurationProducer<T extends RunConfiguration> {
@Nullable
public ConfigurationFromContext createConfigurationFromContext(ConfigurationContext context) {
final RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(context);
if (!setupConfigurationFromContext((T)settings.getConfiguration(), context)) {
final Ref<PsiElement> locationRef = new Ref<PsiElement>(context.getPsiLocation());
if (!setupConfigurationFromContext((T)settings.getConfiguration(), context, locationRef)) {
return null;
}
return new ConfigurationFromContextImpl(settings, context.getPsiLocation());
return new ConfigurationFromContextImpl(settings, locationRef.get());
}
protected abstract boolean setupConfigurationFromContext(T configuration, ConfigurationContext context);
protected abstract boolean setupConfigurationFromContext(T configuration, ConfigurationContext context, Ref<PsiElement> sourceElement);
public abstract boolean isConfigurationFromContext(T configuration, ConfigurationContext context);

5
plugins/groovy/src/org/jetbrains/plugins/groovy/runner/GroovyScriptRunConfigurationProducer.java
View File

@@ -20,6 +20,7 @@ import com.intellij.execution.Location;
import com.intellij.execution.RunManagerEx;
import com.intellij.execution.RunnerAndConfigurationSettings;
import com.intellij.execution.actions.ConfigurationContext;
import com.intellij.execution.actions.ConfigurationFromContext;
import com.intellij.execution.application.ApplicationConfigurationProducer;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.execution.configurations.RunConfigurationModule;
@@ -69,9 +70,9 @@ public class GroovyScriptRunConfigurationProducer extends RuntimeConfigurationPr
if (file.getText().contains("@Grab")) {
ApplicationConfigurationProducer producer = new ApplicationConfigurationProducer();
RunnerAndConfigurationSettings settings = producer.createConfigurationByElement(location, context);
ConfigurationFromContext settings = producer.createConfigurationFromContext(context);
if (settings != null) {
PsiElement src = producer.getSourceElement();
PsiElement src = settings.getSourceElement();
mySourceElement = src;
return createConfiguration(src instanceof PsiMethod ? ((PsiMethod)src).getContainingClass() : (PsiClass)src);
}

2
resources/src/META-INF/IdeaPlugin.xml
View File

@@ -1154,7 +1154,7 @@
<configurationType implementation="com.intellij.execution.applet.AppletConfigurationType"/>
<configurationProducer implementation="com.intellij.execution.applet.AppletConfigurationProducer"/>
<configurationType implementation="com.intellij.execution.application.ApplicationConfigurationType"/>
<configurationProducer implementation="com.intellij.execution.application.ApplicationConfigurationProducer"/>
<runConfigurationProducer implementation="com.intellij.execution.application.ApplicationConfigurationProducer"/>
<configurationType implementation="com.intellij.execution.remote.RemoteConfigurationType"/>
<javaExpressionSurrounder implementation="com.intellij.debugger.codeinsight.JavaWithRuntimeCastSurrounder"/>