plugins/maven/src/main/java/org/jetbrains/idea/maven/execution/MavenRunConfigurationType.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 org.jetbrains.idea.maven.execution;
  17
  18 import com.intellij.compiler.options.CompileStepBeforeRun;
  19 import com.intellij.execution.*;
  20 import com.intellij.execution.configurations.ConfigurationFactory;
  21 import com.intellij.execution.configurations.ConfigurationTypeUtil;
  22 import com.intellij.execution.configurations.RunConfiguration;
  23 import com.intellij.execution.executors.DefaultRunExecutor;
  24 import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
  25 import com.intellij.execution.runners.ExecutionEnvironment;
  26 import com.intellij.execution.runners.ProgramRunner;
  27 import com.intellij.openapi.actionSystem.DataContext;
  28 import com.intellij.openapi.project.Project;
  29 import com.intellij.openapi.util.IconLoader;
  30 import com.intellij.openapi.util.Key;
  31 import com.intellij.openapi.util.text.StringUtil;
  32 import com.intellij.openapi.vfs.LocalFileSystem;
  33 import com.intellij.openapi.vfs.VirtualFile;
  34 import com.intellij.psi.PsiFile;
  35 import org.jetbrains.annotations.NonNls;
  36 import org.jetbrains.annotations.NotNull;
  37 import org.jetbrains.annotations.Nullable;
  38 import org.jetbrains.idea.maven.project.MavenGeneralSettings;
  39 import org.jetbrains.idea.maven.project.MavenProject;
  40 import org.jetbrains.idea.maven.project.MavenProjectsManager;
  41 import org.jetbrains.idea.maven.utils.MavenUtil;
  42
  43 import javax.swing.*;
  44 import java.util.List;
  45
  46 /**
  47  * @author Vladislav.Kaznacheev
  48  */
  49 public class MavenRunConfigurationType implements LocatableConfigurationType {
  50   private final ConfigurationFactory myFactory;
  51   private static final Icon ICON = IconLoader.getIcon("/images/phase.png");
  52   private static final int MAX_NAME_LENGTH = 40;
  53
  54   /**
  55    * reflection
  56    */
  57   MavenRunConfigurationType() {
  58     myFactory = new ConfigurationFactory(this) {
  59       public RunConfiguration createTemplateConfiguration(Project project) {
  60         throw new UnsupportedOperationException();
  61       }
  62
  63       public RunConfiguration createTemplateConfiguration(Project project, RunManager runManager) {
  64         return new MavenRunConfiguration(project, this, "");
  65       }
  66
  67       @Override
  68       public void configureBeforeRunTaskDefaults(Key<? extends BeforeRunTask> providerID, BeforeRunTask task) {
  69         if (providerID == CompileStepBeforeRun.ID) {
  70           task.setEnabled(false);
  71         }
  72       }
  73     };
  74   }
  75
  76   public String getDisplayName() {
  77     return RunnerBundle.message("maven.run.configuration.name");
  78   }
  79
  80   public String getConfigurationTypeDescription() {
  81     return RunnerBundle.message("maven.run.configuration.description");
  82   }
  83
  84   public Icon getIcon() {
  85     return ICON;
  86   }
  87
  88   public ConfigurationFactory[] getConfigurationFactories() {
  89     return new ConfigurationFactory[]{myFactory};
  90   }
  91
  92   @NonNls
  93   @NotNull
  94   public String getId() {
  95     return "MavenRunConfiguration";
  96   }
  97
  98   public static String generateName(Project project, MavenRunnerParameters runnerParameters) {
  99     StringBuilder stringBuilder = new StringBuilder();
 100
 101     final String name = getMavenProjectName(project, runnerParameters);
 102     if (!StringUtil.isEmptyOrSpaces(name)) {
 103       stringBuilder.append(name);
 104       stringBuilder.append(" ");
 105     }
 106
 107     stringBuilder.append("[");
 108     listGoals(stringBuilder, runnerParameters.getGoals());
 109     stringBuilder.append("]");
 110
 111     return stringBuilder.toString();
 112   }
 113
 114   private static void listGoals(final StringBuilder stringBuilder, final List<String> goals) {
 115     int index = 0;
 116     for (String goal : goals) {
 117       if (index != 0) {
 118         if (stringBuilder.length() + goal.length() < MAX_NAME_LENGTH) {
 119           stringBuilder.append(",");
 120         }
 121         else {
 122           stringBuilder.append("...");
 123           break;
 124         }
 125       }
 126       stringBuilder.append(goal);
 127       index++;
 128     }
 129   }
 130
 131   private static String getMavenProjectName(final Project project, final MavenRunnerParameters runnerParameters) {
 132     LocalFileSystem localFileSystem = LocalFileSystem.getInstance();
 133     final VirtualFile virtualFile = localFileSystem.findFileByPath(runnerParameters.getPomFilePath());
 134     if (virtualFile != null) {
 135       MavenProject mavenProject = MavenProjectsManager.getInstance(project).findProject(virtualFile);
 136       if (mavenProject != null) {
 137         if (!StringUtil.isEmptyOrSpaces(mavenProject.getMavenId().getArtifactId())) {
 138           return mavenProject.getMavenId().getArtifactId();
 139         }
 140       }
 141     }
 142     return null;
 143   }
 144
 145   public RunnerAndConfigurationSettings createConfigurationByLocation(Location l) {
 146     final MavenRunnerParameters params = createBuildParameters(l);
 147     if (params == null) return null;
 148     return createRunnerAndConfigurationSettings(null, null, params, l.getProject());
 149   }
 150
 151   public boolean isConfigurationByLocation(RunConfiguration configuration, Location location) {
 152     return configuration instanceof MavenRunConfiguration &&
 153            ((MavenRunConfiguration)configuration).getRunnerParameters().equals(createBuildParameters(location));
 154   }
 155
 156   private static MavenRunnerParameters createBuildParameters(Location l) {
 157     if (!(l instanceof MavenGoalLocation)) return null;
 158
 159     VirtualFile f = ((PsiFile)l.getPsiElement()).getVirtualFile();
 160     List<String> goals = ((MavenGoalLocation)l).getGoals();
 161     List<String> profiles = MavenProjectsManager.getInstance(l.getProject()).getActiveProfiles();
 162
 163     return new MavenRunnerParameters(true, f.getParent().getPath(), goals, profiles);
 164   }
 165
 166   public static void runConfiguration(Project project,
 167                                       MavenRunnerParameters params,
 168                                       DataContext dataContext,
 169                                       @Nullable ProgramRunner.Callback callback) {
 170     MavenGeneralSettings settings = MavenProjectsManager.getInstance(project).getGeneralSettings();
 171     MavenRunnerSettings runnerSettings = MavenRunner.getInstance(project).getState();
 172     runConfiguration(project, params, settings, runnerSettings, dataContext, callback);
 173   }
 174
 175   public static void runConfiguration(Project project,
 176                                       MavenRunnerParameters params,
 177                                       MavenGeneralSettings settings,
 178                                       MavenRunnerSettings runnerSettings,
 179                                       DataContext context,
 180                                       @Nullable ProgramRunner.Callback callback) {
 181     RunnerAndConfigurationSettings configSettings = createRunnerAndConfigurationSettings(settings,
 182                                                                                          runnerSettings,
 183                                                                                          params,
 184                                                                                          project);
 185
 186     ProgramRunner runner = RunnerRegistry.getInstance().findRunnerById(DefaultRunExecutor.EXECUTOR_ID);
 187     ExecutionEnvironment env = new ExecutionEnvironment(runner, configSettings, context);
 188     Executor executor = DefaultRunExecutor.getRunExecutorInstance();
 189
 190     try {
 191       runner.execute(executor, env, callback);
 192     }
 193     catch (ExecutionException e) {
 194       MavenUtil.showError(project, "Failed to execute Maven goal", e);
 195     }
 196   }
 197
 198   private static RunnerAndConfigurationSettings createRunnerAndConfigurationSettings(MavenGeneralSettings generalSettings,
 199                                                                                      MavenRunnerSettings runnerSettings,
 200                                                                                      MavenRunnerParameters params,
 201                                                                                      Project project) {
 202     MavenRunConfigurationType type = ConfigurationTypeUtil.findConfigurationType(MavenRunConfigurationType.class);
 203
 204     final RunnerAndConfigurationSettingsImpl settings = RunManagerEx.getInstanceEx(project)
 205       .createConfiguration(generateName(project, params), type.myFactory);
 206     MavenRunConfiguration runConfiguration = (MavenRunConfiguration)settings.getConfiguration();
 207     runConfiguration.setRunnerParameters(params);
 208     if (generalSettings != null) runConfiguration.setGeneralSettings(generalSettings);
 209     if (runnerSettings != null) runConfiguration.setRunnerSettings(runnerSettings);
 210
 211     return settings;
 212   }
 213 }