plugins/groovy/src/org/jetbrains/plugins/groovy/compiler/generator/GroovycStubGenerator.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
  17 package org.jetbrains.plugins.groovy.compiler.generator;
  18
  19 import com.intellij.compiler.impl.TranslatingCompilerFilesMonitor;
  20 import com.intellij.openapi.application.Result;
  21 import com.intellij.openapi.command.WriteCommandAction;
  22 import com.intellij.openapi.compiler.CompileContext;
  23 import com.intellij.openapi.compiler.CompileScope;
  24 import com.intellij.openapi.compiler.CompilerPaths;
  25 import com.intellij.openapi.compiler.ex.CompileContextEx;
  26 import com.intellij.openapi.compiler.options.ExcludedEntriesConfiguration;
  27 import com.intellij.openapi.fileTypes.StdFileTypes;
  28 import com.intellij.openapi.module.Module;
  29 import com.intellij.openapi.module.ModuleUtil;
  30 import com.intellij.openapi.project.Project;
  31 import com.intellij.openapi.util.io.FileUtil;
  32 import com.intellij.openapi.vfs.LocalFileSystem;
  33 import com.intellij.openapi.vfs.VfsUtil;
  34 import com.intellij.openapi.vfs.VirtualFile;
  35 import com.intellij.util.Chunk;
  36 import org.jetbrains.annotations.NotNull;
  37 import org.jetbrains.plugins.groovy.GroovyFileType;
  38 import org.jetbrains.plugins.groovy.compiler.GroovyCompilerBase;
  39 import org.jetbrains.plugins.groovy.compiler.GroovyCompilerConfiguration;
  40
  41 import java.io.File;
  42 import java.io.IOException;
  43 import java.util.ArrayList;
  44 import java.util.List;
  45
  46 /**
  47  * @author peter
  48  */
  49 public class GroovycStubGenerator extends GroovyCompilerBase {
  50
  51   public GroovycStubGenerator(Project project) {
  52     super(project);
  53   }
  54
  55   @Override
  56   public void compile(CompileContext compileContext, Chunk<Module> moduleChunk, VirtualFile[] virtualFiles, OutputSink sink) {
  57     if (!GroovyCompilerConfiguration.getInstance(myProject).isUseGroovycStubs()) {
  58       return;
  59     }
  60
  61     final CompileScope scope = compileContext.getCompileScope();
  62     final VirtualFile[] javaFiles = scope.getFiles(StdFileTypes.JAVA, true);
  63     if (javaFiles.length == 0) {
  64       return;
  65     }
  66
  67     boolean hasJava = false;
  68     for (VirtualFile javaFile : javaFiles) {
  69       final Module module = ModuleUtil.findModuleForFile(javaFile, myProject);
  70       if (module != null && moduleChunk.containsNode(module)) {
  71         hasJava = true;
  72         break;
  73       }
  74     }
  75
  76     if (!hasJava) {
  77       return;
  78     }
  79
  80     boolean hasGroovy = false;
  81     final ExcludedEntriesConfiguration excluded = GroovyCompilerConfiguration.getExcludeConfiguration(myProject);
  82     List<VirtualFile> total = new ArrayList<VirtualFile>();
  83     for (final VirtualFile virtualFile : virtualFiles) {
  84       if (!excluded.isExcluded(virtualFile)) {
  85         total.add(virtualFile);
  86         if (virtualFile.getFileType() == GroovyFileType.GROOVY_FILE_TYPE) {
  87           hasGroovy = true;
  88         }
  89       }
  90     }
  91
  92     if (!hasGroovy) {
  93       return;
  94     }
  95
  96     super.compile(compileContext, moduleChunk, VfsUtil.toVirtualFileArray(total), sink);
  97   }
  98
  99   @Override
 100   protected void compileFiles(CompileContext compileContext, Module module,
 101                               final List<VirtualFile> toCompile, OutputSink sink, boolean tests) {
 102     boolean hasGroovy = false;
 103     boolean hasJava = false;
 104     for (final VirtualFile file : toCompile) {
 105       if (file.getFileType() == StdFileTypes.JAVA) {
 106         hasJava = true;
 107       }
 108       if (file.getFileType() == GroovyFileType.GROOVY_FILE_TYPE) {
 109         hasGroovy = true;
 110       }
 111     }
 112
 113     if (!hasGroovy) {
 114       return;
 115     }
 116
 117     final String rootPath = CompilerPaths.getGeneratedDataDirectory(myProject) + "/groovyStubs/";
 118     final File outDir = new File(rootPath + myProject.getLocationHash() + "/" + module.getName() + "/" + (tests ? "tests" : "production") + "/");
 119     outDir.mkdirs();
 120
 121     if (!hasJava) {
 122       //always pass groovyc stub generator at least 1 java file, or it won't generate stubs
 123       toCompile.add(createMockJavaFile(rootPath));
 124     }
 125
 126     final VirtualFile tempOutput = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(outDir);
 127     assert tempOutput != null;
 128     cleanDirectory(tempOutput);
 129
 130     ((CompileContextEx)compileContext).assignModule(tempOutput, module, tests);
 131
 132     runGroovycCompiler(compileContext, module, toCompile, true, tempOutput, sink, tests);
 133   }
 134
 135   private VirtualFile createMockJavaFile(final String rootPath) {
 136     return new WriteCommandAction<VirtualFile>(myProject) {
 137       protected void run(Result<VirtualFile> result) throws Throwable {
 138         final VirtualFile root = LocalFileSystem.getInstance().refreshAndFindFileByPath(FileUtil.toSystemIndependentName(rootPath));
 139         final String sampleClassName = "$$$VeryEmptyJavaClass$$$";
 140         assert root != null;
 141         final VirtualFile sampleClass = root.findOrCreateChildData(this, sampleClassName + ".java");
 142         VfsUtil.saveText(sampleClass, "public class " + sampleClassName + " {}");
 143         result.setResult(sampleClass);
 144       }
 145     }.execute().getResultObject();
 146   }
 147
 148   private void cleanDirectory(final VirtualFile dir) {
 149     new WriteCommandAction(myProject) {
 150       protected void run(Result result) throws Throwable {
 151         deleteChildrenRecursively(dir);
 152       }
 153
 154       private void deleteChildrenRecursively(final VirtualFile dir) throws IOException {
 155         for (final VirtualFile child : dir.getChildren()) {
 156           if (child.isDirectory()) {
 157             deleteChildrenRecursively(child);
 158           }
 159           TranslatingCompilerFilesMonitor.removeSourceInfo(child);
 160           try {
 161             child.delete(this);
 162           }
 163           catch (IOException ignored) {
 164             //may be a leaked handle from some non-completely terminated compiler process, or compiler caches, or something else
 165             //not a big deal, we'll delete it next time
 166           }
 167         }
 168       }
 169     }.execute();
 170   }
 171
 172   @Override
 173   public boolean isCompilableFile(VirtualFile file, CompileContext context) {
 174     return super.isCompilableFile(file, context) || StdFileTypes.JAVA == file.getFileType();
 175   }
 176
 177   @NotNull
 178   public String getDescription() {
 179     return "Groovy to java source code generator";
 180   }
 181
 182   public boolean validateConfiguration(CompileScope scope) {
 183     return true;
 184   }
 185
 186 }