java/execution/openapi/src/com/intellij/execution/JavaExecutionUtil.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.execution;
  17
  18 import com.intellij.execution.configurations.*;
  19 import com.intellij.execution.executors.DefaultRunExecutor;
  20 import com.intellij.execution.filters.Filter;
  21 import com.intellij.execution.filters.TextConsoleBuilder;
  22 import com.intellij.execution.filters.TextConsoleBuilderFactory;
  23 import com.intellij.execution.runners.ProgramRunner;
  24 import com.intellij.execution.runners.ExecutionEnvironment;
  25 import com.intellij.execution.util.ExecutionErrorDialog;
  26 import com.intellij.openapi.actionSystem.DataContext;
  27 import com.intellij.openapi.project.Project;
  28 import com.intellij.openapi.module.Module;
  29 import com.intellij.openapi.module.ModuleUtil;
  30 import com.intellij.psi.*;
  31 import com.intellij.psi.util.PsiTreeUtil;
  32 import com.intellij.psi.util.PsiClassUtil;
  33 import com.intellij.psi.search.GlobalSearchScope;
  34 import org.jetbrains.annotations.NotNull;
  35 import org.jetbrains.annotations.Nullable;
  36
  37 import javax.swing.*;
  38
  39 /**
  40  * @author spleaner
  41  */
  42 public class JavaExecutionUtil {
  43   private JavaExecutionUtil() {
  44   }
  45
  46   public static boolean executeRun(@NotNull final Project project, String contentName, Icon icon,
  47                       final DataContext dataContext) throws ExecutionException {
  48     return executeRun(project, contentName, icon, dataContext, null);
  49   }
  50
  51   public static boolean executeRun(@NotNull final Project project, String contentName, Icon icon, DataContext dataContext, Filter[] filters) throws ExecutionException {
  52     final JavaParameters cmdLine = JavaParameters.JAVA_PARAMETERS.getData(dataContext);
  53     final DefaultRunProfile profile = new DefaultRunProfile(project, cmdLine, contentName, icon, filters);
  54     final ProgramRunner runner = RunnerRegistry.getInstance().getRunner(DefaultRunExecutor.EXECUTOR_ID, profile);
  55     if (runner != null) {
  56       runner.execute(DefaultRunExecutor.getRunExecutorInstance(), new ExecutionEnvironment(profile, dataContext));
  57       return true;
  58     }
  59
  60     return false;
  61   }
  62
  63   private static final class DefaultRunProfile implements RunProfile {
  64     private final JavaParameters myParameters;
  65     private final String myContentName;
  66     private final Filter[] myFilters;
  67     private final Project myProject;
  68     private Icon myIcon;
  69
  70     public DefaultRunProfile(final Project project, final JavaParameters parameters, final String contentName, final Icon icon, Filter[] filters) {
  71       myProject = project;
  72       myParameters = parameters;
  73       myContentName = contentName;
  74       myFilters = filters;
  75       myIcon = icon;
  76     }
  77
  78     public Icon getIcon() {
  79       return myIcon;
  80     }
  81
  82     public RunProfileState getState(@NotNull final Executor executor, @NotNull final ExecutionEnvironment env) throws ExecutionException {
  83       final JavaCommandLineState state = new JavaCommandLineState(env) {
  84         protected JavaParameters createJavaParameters() {
  85           return myParameters;
  86         }
  87       };
  88       final TextConsoleBuilder builder = TextConsoleBuilderFactory.getInstance().createBuilder(myProject);
  89       if (myFilters != null) {
  90         for (final Filter myFilter : myFilters) {
  91           builder.addFilter(myFilter);
  92         }
  93       }
  94       state.setConsoleBuilder(builder);
  95       return state;
  96     }
  97
  98     public String getName() {
  99       return myContentName;
 100     }
 101
 102     public void checkConfiguration() {}
 103
 104   }
 105
 106   @Nullable
 107   public static String getRuntimeQualifiedName(final PsiClass aClass) {
 108     final PsiClass containingClass = aClass.getContainingClass();
 109     if (containingClass != null) {
 110       final String parentName = getRuntimeQualifiedName(containingClass);
 111       return parentName + "$" + aClass.getName();
 112     }
 113     else {
 114       return aClass.getQualifiedName();
 115     }
 116   }
 117
 118   @Nullable
 119   public static String getPresentableClassName(final String rtClassName, final JavaRunConfigurationModule configurationModule) {
 120     final PsiClass psiClass = configurationModule.findClass(rtClassName);
 121     if (psiClass != null) {
 122       return psiClass.getName();
 123     }
 124     final int lastDot = rtClassName.lastIndexOf('.');
 125     if (lastDot == -1 || lastDot == rtClassName.length() - 1) {
 126       return rtClassName;
 127     }
 128     return rtClassName.substring(lastDot + 1, rtClassName.length());
 129   }
 130
 131   public static Module findModule(@NotNull final PsiClass psiClass) {
 132     return ModuleUtil.findModuleForPsiElement(psiClass);
 133   }
 134
 135   @Nullable
 136   public static PsiClass findMainClass(final Module module, final String mainClassName) {
 137     final PsiManager psiManager = PsiManager.getInstance(module.getProject());
 138     return JavaPsiFacade.getInstance(psiManager.getProject())
 139       .findClass(mainClassName.replace('$', '.'), GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module));
 140   }
 141
 142
 143   public static boolean isNewName(final String name) {
 144     return name == null || name.startsWith(ExecutionBundle.message("run.configuration.unnamed.name.prefix"));
 145   }
 146
 147   public static Location stepIntoSingleClass(final Location location) {
 148     PsiElement element = location.getPsiElement();
 149     if (!(element instanceof PsiClassOwner)) {
 150       if (PsiTreeUtil.getParentOfType(element, PsiClass.class) != null) return location;
 151       element = PsiTreeUtil.getParentOfType(element, PsiClassOwner.class);
 152       if (element == null) return location;
 153     }
 154     final PsiClassOwner psiFile = (PsiClassOwner)element;
 155     final PsiClass[] classes = psiFile.getClasses();
 156     if (classes.length != 1) return location;
 157     return PsiLocation.fromPsiElement(classes[0]);
 158   }
 159
 160   public static String getShortClassName(final String fqName) {
 161     if (fqName == null) return "";
 162     final int dotIndex = fqName.lastIndexOf('.');
 163     if (dotIndex == fqName.length() - 1) return "";
 164     if (dotIndex < 0) return fqName;
 165     return fqName.substring(dotIndex + 1, fqName.length());
 166   }
 167
 168   public static void showExecutionErrorMessage(final ExecutionException e, final String title, final Project project) {
 169     ExecutionErrorDialog.show(e, title, project);
 170   }
 171
 172   public static boolean isRunnableClass(final PsiClass aClass) {
 173     return PsiClassUtil.isRunnableClass(aClass, true);
 174   }
 175 }