e90f8d248f8ffc13176c3b245e5791018a306200
[idea/community.git] / 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 }