plugins/groovy/src/org/jetbrains/plugins/groovy/runner/GroovyScriptRunConfiguration.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.plugins.groovy.runner;
  17
  18 import com.intellij.execution.CantRunException;
  19 import com.intellij.execution.ExecutionException;
  20 import com.intellij.execution.Executor;
  21 import com.intellij.execution.configurations.*;
  22 import com.intellij.execution.filters.TextConsoleBuilderFactory;
  23 import com.intellij.execution.runners.ExecutionEnvironment;
  24 import com.intellij.openapi.components.PathMacroManager;
  25 import com.intellij.openapi.module.Module;
  26 import com.intellij.openapi.module.ModuleManager;
  27 import com.intellij.openapi.options.SettingsEditor;
  28 import com.intellij.openapi.project.Project;
  29 import com.intellij.openapi.roots.ModuleRootManager;
  30 import com.intellij.openapi.roots.ProjectRootManager;
  31 import com.intellij.openapi.util.InvalidDataException;
  32 import com.intellij.openapi.util.JDOMExternalizer;
  33 import com.intellij.openapi.util.WriteExternalException;
  34 import com.intellij.openapi.util.io.FileUtil;
  35 import com.intellij.openapi.vfs.LocalFileSystem;
  36 import com.intellij.openapi.vfs.VirtualFile;
  37 import com.intellij.openapi.projectRoots.Sdk;
  38 import com.intellij.openapi.projectRoots.JavaSdkType;
  39 import com.intellij.openapi.projectRoots.SimpleJavaSdkType;
  40 import com.intellij.psi.PsiFile;
  41 import com.intellij.psi.PsiManager;
  42 import com.intellij.util.PathUtil;
  43 import com.intellij.util.SystemProperties;
  44 import org.jdom.Element;
  45 import org.jetbrains.annotations.NotNull;
  46 import org.jetbrains.annotations.Nullable;
  47 import org.jetbrains.plugins.groovy.extensions.GroovyScriptType;
  48 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
  49
  50 import java.io.File;
  51 import java.util.ArrayList;
  52 import java.util.Arrays;
  53 import java.util.Collection;
  54
  55 /**
  56  * @author peter
  57  */
  58 public class GroovyScriptRunConfiguration extends ModuleBasedConfiguration<RunConfigurationModule> {
  59   public String vmParams;
  60   public String workDir;
  61   public boolean isDebugEnabled;
  62   public String scriptParams;
  63   @Nullable public String scriptPath;
  64
  65   public GroovyScriptRunConfiguration(final String name, final Project project, final ConfigurationFactory factory) {
  66     super(name, new RunConfigurationModule(project), factory);
  67     workDir = PathUtil.getLocalPath(project.getBaseDir());
  68   }
  69
  70   @Override
  71   protected ModuleBasedConfiguration createInstance() {
  72     return new GroovyScriptRunConfiguration(getName(), getProject(), getFactory());
  73   }
  74
  75   public void setWorkDir(String dir) {
  76     workDir = dir;
  77   }
  78
  79   public String getWorkDir() {
  80     return workDir;
  81   }
  82
  83   @Nullable
  84   public Module getModule() {
  85     return getConfigurationModule().getModule();
  86   }
  87
  88   private String getAbsoluteWorkDir() {
  89     if (!new File(workDir).isAbsolute()) {
  90       return new File(getProject().getLocation(), workDir).getAbsolutePath();
  91     }
  92     return workDir;
  93   }
  94
  95   public Collection<Module> getValidModules() {
  96     Module[] modules = ModuleManager.getInstance(getProject()).getModules();
  97     final GroovyScriptRunner scriptRunner = findConfiguration();
  98     if (scriptRunner == null) {
  99       return Arrays.asList(modules);
 100     }
 101
 102
 103     ArrayList<Module> res = new ArrayList<Module>();
 104     for (Module module : modules) {
 105       if (scriptRunner.isValidModule(module)) {
 106         res.add(module);
 107       }
 108     }
 109     return res;
 110   }
 111
 112   @Nullable
 113   private GroovyScriptRunner findConfiguration() {
 114     final VirtualFile scriptFile = getScriptFile();
 115     if (scriptFile == null) {
 116       return null;
 117     }
 118
 119     final PsiFile psiFile = PsiManager.getInstance(getProject()).findFile(scriptFile);
 120     if (!(psiFile instanceof GroovyFile) || !((GroovyFile)psiFile).isScript()) {
 121       return null;
 122     }
 123
 124     return GroovyScriptType.getScriptType((GroovyFile)psiFile).getRunner();
 125   }
 126
 127   public void readExternal(Element element) throws InvalidDataException {
 128     PathMacroManager.getInstance(getProject()).expandPaths(element);
 129     super.readExternal(element);
 130     readModule(element);
 131     scriptPath = JDOMExternalizer.readString(element, "path");
 132     vmParams = JDOMExternalizer.readString(element, "vmparams");
 133     scriptParams = JDOMExternalizer.readString(element, "params");
 134     final String wrk = JDOMExternalizer.readString(element, "workDir");
 135     if (!".".equals(wrk)) {
 136       workDir = wrk;
 137     }
 138     isDebugEnabled = Boolean.parseBoolean(JDOMExternalizer.readString(element, "debug"));
 139   }
 140
 141   public void writeExternal(Element element) throws WriteExternalException {
 142     super.writeExternal(element);
 143     writeModule(element);
 144     JDOMExternalizer.write(element, "path", scriptPath);
 145     JDOMExternalizer.write(element, "vmparams", vmParams);
 146     JDOMExternalizer.write(element, "params", scriptParams);
 147     JDOMExternalizer.write(element, "workDir", workDir);
 148     JDOMExternalizer.write(element, "debug", isDebugEnabled);
 149     PathMacroManager.getInstance(getProject()).collapsePathsRecursively(element);
 150   }
 151
 152   public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment environment) throws ExecutionException {
 153     final VirtualFile script = getScriptFile();
 154     if (script == null) {
 155       throw new CantRunException("Cannot find script " + scriptPath);
 156     }
 157
 158     final GroovyScriptRunner scriptRunner = findConfiguration();
 159     if (scriptRunner == null) {
 160       throw new CantRunException("Unknown script type " + scriptPath);
 161     }
 162
 163     final Module module = getModule();
 164     if (!scriptRunner.ensureRunnerConfigured(module, getName(), getProject())) {
 165       return null;
 166     }
 167
 168     final boolean tests = ProjectRootManager.getInstance(getProject()).getFileIndex().isInTestSourceContent(script);
 169
 170     final JavaCommandLineState state = new JavaCommandLineState(environment) {
 171       protected JavaParameters createJavaParameters() throws ExecutionException {
 172         JavaParameters params = new JavaParameters();
 173         params.setCharset(null);
 174
 175         if (module != null) {
 176           final Sdk sdk = ModuleRootManager.getInstance(module).getSdk();
 177           if (sdk != null && sdk.getSdkType() instanceof JavaSdkType) {
 178             params.setJdk(sdk);
 179           }
 180         }
 181         if (params.getJdk() == null) {
 182           params.setJdk(new SimpleJavaSdkType().createJdk("tmp", SystemProperties.getJavaHome()));
 183         }
 184         params.setWorkingDirectory(getAbsoluteWorkDir());
 185
 186         scriptRunner.configureCommandLine(params, module, tests, script, GroovyScriptRunConfiguration.this);
 187
 188         return params;
 189       }
 190     };
 191
 192     state.setConsoleBuilder(TextConsoleBuilderFactory.getInstance().createBuilder(getProject()));
 193     return state;
 194
 195   }
 196
 197   @Nullable
 198   private VirtualFile getScriptFile() {
 199     if (scriptPath == null) return null;
 200     return LocalFileSystem.getInstance().findFileByPath(FileUtil.toSystemIndependentName(scriptPath));
 201   }
 202
 203
 204   public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
 205     return new GroovyRunConfigurationEditor();
 206   }
 207 }