platform/testRunner/src/com/intellij/execution/testframework/SourceScope.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.testframework;
  17
  18 import com.intellij.openapi.module.Module;
  19 import com.intellij.openapi.module.ModuleManager;
  20 import com.intellij.openapi.project.Project;
  21 import com.intellij.openapi.vfs.VirtualFile;
  22 import com.intellij.psi.search.GlobalSearchScope;
  23 import com.intellij.util.containers.HashMap;
  24 import com.intellij.util.graph.Graph;
  25 import org.jetbrains.annotations.NotNull;
  26
  27 import java.util.*;
  28
  29 /**
  30  * @author dyoma
  31  */
  32 public abstract class SourceScope {
  33   public abstract GlobalSearchScope getGlobalSearchScope();
  34   public abstract Project getProject();
  35   public abstract GlobalSearchScope getLibrariesScope();
  36
  37   public static Map<Module, Collection<Module>> buildAllDependencies(final Project project) {
  38     Graph<Module> graph = ModuleManager.getInstance(project).moduleGraph();
  39     Map<Module, Collection<Module>> result = new HashMap<Module, Collection<Module>>();
  40     for (final Module module : graph.getNodes()) {
  41       buildDependenciesForModule(module, graph, result);
  42     }
  43     return result;
  44   }
  45
  46   private static void buildDependenciesForModule(final Module module, final Graph<Module> graph, Map<Module, Collection<Module>> map) {
  47     final Set<Module> deps = new com.intellij.util.containers.HashSet<Module>();
  48     map.put(module, deps);
  49
  50     new Object() {
  51       void traverse(Module m) {
  52         for (Iterator<Module> iterator = graph.getIn(m); iterator.hasNext();) {
  53           final Module dep = iterator.next();
  54           if (!deps.contains(dep)) {
  55             deps.add(dep);
  56             traverse(dep);
  57           }
  58         }
  59       }
  60     }.traverse(module);
  61   }
  62
  63   private abstract static class ModuleSourceScope extends SourceScope {
  64     private final Project myProject;
  65
  66     protected ModuleSourceScope(final Project project) {
  67       myProject = project;
  68     }
  69
  70     public Project getProject() {
  71       return myProject;
  72     }
  73
  74   }
  75
  76   public static SourceScope wholeProject(final Project project) {
  77     return new SourceScope() {
  78       public GlobalSearchScope getGlobalSearchScope() {
  79         return GlobalSearchScope.allScope(project);
  80       }
  81
  82       public Project getProject() {
  83         return project;
  84       }
  85
  86       public Module[] getModulesToCompile() {
  87         return ModuleManager.getInstance(project).getModules();
  88       }
  89
  90       public GlobalSearchScope getLibrariesScope() {
  91         return getGlobalSearchScope();
  92       }
  93     };
  94   }
  95
  96   public static SourceScope modulesWithDependencies(final Module[] modules) {
  97     if (modules == null || modules.length == 0) return null;
  98     return new ModuleSourceScope(modules[0].getProject()) {
  99       public GlobalSearchScope getGlobalSearchScope() {
 100         return evaluateScopesAndUnite(modules, new ScopeForModuleEvaluator() {
 101           public GlobalSearchScope evaluate(final Module module) {
 102             return GlobalSearchScope.moduleWithDependenciesScope(module);
 103           }
 104         });
 105       }
 106
 107       public GlobalSearchScope getLibrariesScope() {
 108         return evaluateScopesAndUnite(modules, new ScopeForModuleEvaluator() {
 109           public GlobalSearchScope evaluate(final Module module) {
 110             return new ModuleWithDependenciesAndLibsDependencies(module);
 111           }
 112         });
 113       }
 114
 115       public Module[] getModulesToCompile() {
 116         return modules;
 117       }
 118     };
 119   }
 120
 121   private interface ScopeForModuleEvaluator {
 122     GlobalSearchScope evaluate(Module module);
 123   }
 124   private static GlobalSearchScope evaluateScopesAndUnite(final Module[] modules, final ScopeForModuleEvaluator evaluator) {
 125     GlobalSearchScope scope = evaluator.evaluate(modules[0]);
 126     for (int i = 1; i < modules.length; i++) {
 127       final Module module = modules[i];
 128       final GlobalSearchScope otherscope = evaluator.evaluate(module);
 129       scope = scope.uniteWith(otherscope);
 130     }
 131     return scope;
 132   }
 133
 134   public static SourceScope modules(final Module[] modules) {
 135     if (modules == null || modules.length == 0) return null;
 136     return new ModuleSourceScope(modules[0].getProject()) {
 137       public GlobalSearchScope getGlobalSearchScope() {
 138         return evaluateScopesAndUnite(modules, new ScopeForModuleEvaluator() {
 139           public GlobalSearchScope evaluate(final Module module) {
 140             return GlobalSearchScope.moduleScope(module);
 141           }
 142         });
 143       }
 144
 145       public GlobalSearchScope getLibrariesScope() {
 146         return evaluateScopesAndUnite(modules, new ScopeForModuleEvaluator() {
 147           public GlobalSearchScope evaluate(final Module module) {
 148             return GlobalSearchScope.moduleWithLibrariesScope(module);
 149           }
 150         });
 151       }
 152
 153       public Module[] getModulesToCompile() {
 154         return modules;
 155       }
 156     };
 157   }
 158
 159   public abstract Module[] getModulesToCompile();
 160
 161   private static class ModuleWithDependenciesAndLibsDependencies extends GlobalSearchScope {
 162     private final GlobalSearchScope myMainScope;
 163     private final Collection<GlobalSearchScope> myScopes = new ArrayList<GlobalSearchScope>();
 164
 165     public ModuleWithDependenciesAndLibsDependencies(final Module module) {
 166       super(module.getProject());
 167       myMainScope = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module);
 168       final Map<Module, Collection<Module>> map = buildAllDependencies(module.getProject());
 169       if (map == null) return;
 170       final Collection<Module> modules = map.get(module);
 171       for (final Module dependency : modules) {
 172         myScopes.add(GlobalSearchScope.moduleWithLibrariesScope(dependency));
 173       }
 174     }
 175
 176     public boolean contains(final VirtualFile file) {
 177       return findScopeFor(file) != null;
 178     }
 179
 180     public int compare(final VirtualFile file1, final VirtualFile file2) {
 181       final GlobalSearchScope scope = findScopeFor(file1);
 182       if (scope.contains(file2)) return scope.compare(file1, file2);
 183       return 0;
 184     }
 185
 186     public boolean isSearchInModuleContent(@NotNull final Module aModule) {
 187       return myMainScope.isSearchInModuleContent(aModule);
 188     }
 189
 190     public boolean isSearchInLibraries() {
 191       return true;
 192     }
 193
 194     private GlobalSearchScope findScopeFor(final VirtualFile file) {
 195       if (myMainScope.contains(file)) return myMainScope;
 196       for (final GlobalSearchScope scope : myScopes) {
 197         if (scope.contains(file)) return scope;
 198       }
 199       return null;
 200     }
 201   }
 202 }