java/java-impl/src/com/intellij/ide/projectView/impl/nodes/PackageUtil.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.ide.projectView.impl.nodes;
  17
  18 import com.intellij.ide.projectView.ViewSettings;
  19 import com.intellij.ide.util.treeView.AbstractTreeNode;
  20 import com.intellij.ide.util.treeView.TreeViewUtil;
  21 import com.intellij.openapi.module.Module;
  22 import com.intellij.openapi.module.ModuleManager;
  23 import com.intellij.openapi.project.Project;
  24 import com.intellij.openapi.roots.*;
  25 import com.intellij.openapi.util.Comparing;
  26 import com.intellij.openapi.vfs.VirtualFile;
  27 import com.intellij.psi.JavaDirectoryService;
  28 import com.intellij.psi.PsiDirectory;
  29 import com.intellij.psi.PsiManager;
  30 import com.intellij.psi.PsiPackage;
  31 import com.intellij.psi.search.GlobalSearchScope;
  32 import org.jetbrains.annotations.NotNull;
  33
  34 import java.util.*;
  35
  36 public class PackageUtil {
  37
  38   public static PsiPackage[] getSubpackages(PsiPackage aPackage,
  39                                             Module module,
  40                                             final Project project,
  41                                             final boolean searchInLibraries) {
  42     final GlobalSearchScope scopeToShow = getScopeToShow(project, module, searchInLibraries);
  43     final PsiDirectory[] dirs = aPackage.getDirectories(scopeToShow);
  44     final Set<PsiPackage> subpackages = new HashSet<PsiPackage>();
  45     for (PsiDirectory dir : dirs) {
  46       final PsiDirectory[] subdirectories = dir.getSubdirectories();
  47       for (PsiDirectory subdirectory : subdirectories) {
  48         final PsiPackage psiPackage = JavaDirectoryService.getInstance().getPackage(subdirectory);
  49         if (psiPackage != null) {
  50           final String name = psiPackage.getName();
  51           // skip "default" subpackages as they should be attributed to other modules
  52           // this is the case when contents of one module is nested into contents of another
  53           if (name != null && !"".equals(name)) {
  54             subpackages.add(psiPackage);
  55           }
  56         }
  57       }
  58     }
  59     return subpackages.toArray(new PsiPackage[subpackages.size()]);
  60   }
  61
  62   public static void addPackageAsChild(final Collection<AbstractTreeNode> children,
  63                                        final PsiPackage aPackage,
  64                                        Module module,
  65                                        ViewSettings settings,
  66                                        final boolean inLibrary) {
  67     final boolean shouldSkipPackage = settings.isHideEmptyMiddlePackages() && isPackageEmpty(aPackage, module, !settings.isFlattenPackages(), inLibrary);
  68     final Project project = aPackage.getProject();
  69     if (!shouldSkipPackage) {
  70       children.add(new PackageElementNode(project,
  71                                           new PackageElement(module, aPackage, inLibrary), settings));
  72     }
  73     if (settings.isFlattenPackages() || shouldSkipPackage) {
  74       final PsiPackage[] subpackages = getSubpackages(aPackage, module, project, inLibrary);
  75       for (PsiPackage subpackage : subpackages) {
  76         addPackageAsChild(children, subpackage, module, settings, inLibrary);
  77       }
  78     }
  79   }
  80
  81   public static boolean isPackageEmpty(PsiPackage aPackage,
  82                                        Module module,
  83                                        boolean strictlyEmpty,
  84                                        final boolean inLibrary) {
  85     final Project project = aPackage.getProject();
  86     final GlobalSearchScope scopeToShow = getScopeToShow(project, module, inLibrary);
  87     final PsiDirectory[] dirs = aPackage.getDirectories(scopeToShow);
  88     for (final PsiDirectory dir : dirs) {
  89       if (!TreeViewUtil.isEmptyMiddlePackage(dir, strictlyEmpty)) {
  90         return false;
  91       }
  92     }
  93     return true;
  94   }
  95
  96   public static GlobalSearchScope getScopeToShow(final Project project, final Module module, boolean forLibraries) {
  97     if (module != null) {
  98       if (forLibraries) {
  99         return new ModuleLibrariesSearchScope(module);
 100       }
 101       else {
 102         return GlobalSearchScope.moduleScope(module);
 103       }
 104     }
 105     else {
 106       if (forLibraries) {
 107         return new ProjectLibrariesSearchScope(project);
 108       }
 109       else {
 110         return GlobalSearchScope.projectScope(project);
 111       }
 112     }
 113   }
 114
 115
 116   public static boolean isPackageDefault(PsiPackage directoryPackage) {
 117     final String qName = directoryPackage.getQualifiedName();
 118     return qName.length() == 0;
 119   }
 120
 121   public static Collection<AbstractTreeNode> createPackageViewChildrenOnFiles(final List<VirtualFile> sourceRoots,
 122                                                                               final Project project,
 123                                                                               final ViewSettings settings,
 124                                                                               final Module module,
 125                                                                               final boolean inLibrary) {
 126     final PsiManager psiManager = PsiManager.getInstance(project);
 127
 128     final List<AbstractTreeNode> children = new ArrayList<AbstractTreeNode>();
 129     final Set<PsiPackage> topLevelPackages = new HashSet<PsiPackage>();
 130
 131     for (final VirtualFile root : sourceRoots) {
 132       final PsiDirectory directory = psiManager.findDirectory(root);
 133       if (directory == null) {
 134         continue;
 135       }
 136       final PsiPackage directoryPackage = JavaDirectoryService.getInstance().getPackage(directory);
 137       if (directoryPackage == null || isPackageDefault(directoryPackage)) {
 138         // add subpackages
 139         final PsiDirectory[] subdirectories = directory.getSubdirectories();
 140         for (PsiDirectory subdirectory : subdirectories) {
 141           final PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage(subdirectory);
 142           if (aPackage != null && !isPackageDefault(aPackage)) {
 143             topLevelPackages.add(aPackage);
 144           }
 145         }
 146         // add non-dir items
 147         children.addAll(ProjectViewDirectoryHelper.getInstance(project).getDirectoryChildren(directory, settings, false));
 148       }
 149       else {
 150         topLevelPackages.add(directoryPackage);
 151       }
 152     }
 153
 154     for (final PsiPackage topLevelPackage : topLevelPackages) {
 155       addPackageAsChild(children, topLevelPackage, module, settings, inLibrary);
 156     }
 157
 158     return children;
 159   }
 160
 161   public static String getNodeName(final ViewSettings settings, final PsiPackage aPackage, final PsiPackage parentPackageInTree, String defaultShortName,
 162                             boolean isFQNameShown) {
 163     final String name;
 164     if (isFQNameShown) {
 165       name = settings.isAbbreviatePackageNames() ? TreeViewUtil.calcAbbreviatedPackageFQName(aPackage) : aPackage.getQualifiedName();
 166     }
 167     else if (parentPackageInTree != null) {
 168       PsiPackage parentPackage = aPackage.getParentPackage();
 169       final StringBuilder buf = new StringBuilder();
 170       buf.append(aPackage.getName());
 171       while (parentPackage != null && !parentPackage.equals(parentPackageInTree)) {
 172         final String parentPackageName = parentPackage.getName();
 173         if (parentPackageName == null || "".equals(parentPackageName)) {
 174           break; // reached default package
 175         }
 176         buf.insert(0, ".");
 177         buf.insert(0, parentPackageName);
 178         parentPackage = parentPackage.getParentPackage();
 179       }
 180       name = buf.toString();
 181     }
 182     else {
 183       name = defaultShortName;
 184     }
 185     return name;
 186   }
 187
 188   private static class ModuleLibrariesSearchScope extends GlobalSearchScope {
 189     private final Module myModule;
 190
 191     public ModuleLibrariesSearchScope(final Module module) {
 192       super(module.getProject());
 193       myModule = module;
 194     }
 195
 196     public boolean contains(VirtualFile file) {
 197       final OrderEntry orderEntry = ModuleRootManager.getInstance(myModule).getFileIndex().getOrderEntryForFile(file);
 198       return orderEntry instanceof JdkOrderEntry || orderEntry instanceof LibraryOrderEntry;
 199     }
 200
 201     public int compare(VirtualFile file1, VirtualFile file2) {
 202       final ModuleFileIndex fileIndex = ModuleRootManager.getInstance(myModule).getFileIndex();
 203       return Comparing.compare(fileIndex.getOrderEntryForFile(file2), fileIndex.getOrderEntryForFile(file1));
 204     }
 205
 206     public boolean isSearchInModuleContent(@NotNull Module aModule) {
 207       return false;
 208     }
 209
 210     public boolean isSearchInLibraries() {
 211       return true;
 212     }
 213   }
 214
 215   private static class ProjectLibrariesSearchScope extends GlobalSearchScope {
 216
 217     public ProjectLibrariesSearchScope(final Project project) {
 218       super(project);
 219     }
 220
 221     private static Module[] getModules(final Project project) {
 222       return ModuleManager.getInstance(project).getModules();
 223     }
 224
 225     public boolean contains(VirtualFile file) {
 226       final Module[] modules = getModules(getProject());
 227       for (Module module : modules) {
 228         final OrderEntry orderEntryForFile = ModuleRootManager.getInstance(module).getFileIndex().getOrderEntryForFile(file);
 229         if (orderEntryForFile instanceof JdkOrderEntry || orderEntryForFile instanceof LibraryOrderEntry) return true;
 230       }
 231       return false;
 232     }
 233
 234     public int compare(VirtualFile file1, VirtualFile file2) {
 235       final Module[] modules = getModules(getProject());
 236       for (Module module : modules) {
 237         final ModuleFileIndex fileIndex = ModuleRootManager.getInstance(module).getFileIndex();
 238         final OrderEntry orderEntry1 = fileIndex.getOrderEntryForFile(file1);
 239         if (orderEntry1 != null) {
 240           final OrderEntry orderEntry2 = fileIndex.getOrderEntryForFile(file2);
 241           if (orderEntry2 != null) {
 242             return orderEntry2.compareTo(orderEntry1);
 243           }
 244           else {
 245             return 0;
 246           }
 247         }
 248       }
 249       return 0;
 250     }
 251
 252     public boolean isSearchInModuleContent(@NotNull Module aModule) {
 253       return false;
 254     }
 255
 256     public boolean isSearchInLibraries() {
 257       return true;
 258     }
 259   }
 260 }