plugins/maven/src/main/java/org/jetbrains/idea/maven/dom/MavenDomProjectProcessorUtils.java

   1 /*
   2  * Copyright 2000-2010 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.idea.maven.dom;
  17
  18 import com.intellij.openapi.project.Project;
  19 import com.intellij.openapi.util.text.StringUtil;
  20 import com.intellij.openapi.vfs.VirtualFile;
  21 import com.intellij.psi.xml.XmlTag;
  22 import com.intellij.util.Function;
  23 import com.intellij.util.Processor;
  24 import com.intellij.util.containers.hash.HashSet;
  25 import com.intellij.util.xml.DomUtil;
  26 import org.jetbrains.annotations.NotNull;
  27 import org.jetbrains.annotations.Nullable;
  28 import org.jetbrains.idea.maven.dom.MavenDomUtil;
  29 import org.jetbrains.idea.maven.dom.model.*;
  30 import org.jetbrains.idea.maven.project.*;
  31 import org.jetbrains.idea.maven.utils.MavenUtil;
  32
  33 import java.util.Arrays;
  34 import java.util.Collection;
  35 import java.util.Set;
  36
  37 public class MavenDomProjectProcessorUtils {
  38   private MavenDomProjectProcessorUtils() {
  39   }
  40
  41   @Nullable
  42   public static XmlTag searchProperty(@NotNull final String propertyName,
  43                                       @NotNull MavenDomProjectModel projectDom,
  44                                       @NotNull final Project project) {
  45     final XmlTag[] property = new XmlTag[]{null};
  46
  47     Processor<MavenDomProperties> searchProcessor = new Processor<MavenDomProperties>() {
  48       public boolean process(MavenDomProperties mavenDomProperties) {
  49         XmlTag propertiesTag = mavenDomProperties.getXmlTag();
  50         if (propertiesTag != null) {
  51           for (XmlTag each : propertiesTag.getSubTags()) {
  52             if (each.getName().equals(propertyName)) {
  53               property[0] = each;
  54               return true;
  55             }
  56           }
  57         }
  58         return false;
  59       }
  60     };
  61
  62     processProperties(projectDom, searchProcessor, project);
  63
  64     return property[0];
  65   }
  66
  67   @Nullable
  68   public static Set<XmlTag> collectProperties(@NotNull MavenDomProjectModel projectDom, @NotNull final Project project) {
  69     final Set<XmlTag> properties = new HashSet<XmlTag>();
  70
  71     Processor<MavenDomProperties> collectProcessor = new Processor<MavenDomProperties>() {
  72       public boolean process(MavenDomProperties mavenDomProperties) {
  73         XmlTag propertiesTag = mavenDomProperties.getXmlTag();
  74         if (propertiesTag != null) {
  75           properties.addAll(Arrays.asList(propertiesTag.getSubTags()));
  76         }
  77         return false;
  78       }
  79     };
  80
  81     processProperties(projectDom, collectProcessor, project);
  82
  83     return properties;
  84   }
  85
  86   @NotNull
  87   public static Set<MavenDomDependency> searchDependencyUsages(@NotNull final MavenDomDependency dependency,
  88                                                                @NotNull final Project project) {
  89     final Set<MavenDomDependency> usages = new HashSet<MavenDomDependency>();
  90
  91     MavenDomProjectModel model = dependency.getParentOfType(MavenDomProjectModel.class, false);
  92     if (model != null) {
  93       final String artifactId = dependency.getArtifactId().getStringValue();
  94       final String groupId = dependency.getGroupId().getStringValue();
  95       if (artifactId != null && groupId != null) {
  96         Processor<MavenDomProjectModel> collectProcessor = new Processor<MavenDomProjectModel>() {
  97           public boolean process(MavenDomProjectModel mavenDomProjectModel) {
  98             for (MavenDomDependency domDependency : mavenDomProjectModel.getDependencies().getDependencies()) {
  99               if (domDependency.equals(dependency)) continue;
 100               if (artifactId.equals(domDependency.getArtifactId().getStringValue()) &&
 101                   groupId.equals(domDependency.getGroupId().getStringValue())) {
 102                 usages.add(domDependency);
 103               }
 104             }
 105             return false;
 106           }
 107         };
 108
 109         processProjectDependenciesRecursively(model, collectProcessor, project);
 110       }
 111     }
 112
 113     return usages;
 114   }
 115
 116   private static void processProjectDependenciesRecursively(@Nullable MavenDomProjectModel model,
 117                                                             @NotNull Processor<MavenDomProjectModel> processor,
 118                                                             @NotNull Project project) {
 119     if (model != null) {
 120       if (processor.process(model)) return;
 121
 122       MavenProject mavenProject = MavenDomUtil.findProject(model);
 123       if (mavenProject != null) {
 124         for (MavenProject childProject : MavenProjectsManager.getInstance(project).findInheritors(mavenProject)) {
 125           MavenDomProjectModel childProjectModel = MavenDomUtil.getMavenDomProjectModel(project, childProject.getFile());
 126
 127           processProjectDependenciesRecursively(childProjectModel, processor, project);
 128         }
 129       }
 130     }
 131   }
 132
 133   @Nullable
 134   public static MavenDomDependency searchManagingDependency(@NotNull final MavenDomDependency dependency, @NotNull final Project project) {
 135     final MavenDomDependency[] parent = new MavenDomDependency[]{null};
 136
 137     final String artifactId = dependency.getArtifactId().getStringValue();
 138     final String groupId = dependency.getGroupId().getStringValue();
 139     if (artifactId != null && groupId != null) {
 140       MavenDomProjectModel model = dependency.getParentOfType(MavenDomProjectModel.class, false);
 141       if (model != null) {
 142         Processor<MavenDomDependencies> processor = new Processor<MavenDomDependencies>() {
 143           public boolean process(MavenDomDependencies mavenDomDependencies) {
 144             for (MavenDomDependency domDependency : mavenDomDependencies.getDependencies()) {
 145               if (domDependency.equals(dependency)) continue;
 146               if (artifactId.equals(domDependency.getArtifactId().getStringValue()) &&
 147                   groupId.equals(domDependency.getGroupId().getStringValue())) {
 148                 parent[0] = domDependency;
 149                 return true;
 150               }
 151             }
 152             return false;
 153           }
 154         };
 155         processDependenciesInDependencyManagement(model, processor, project);
 156       }
 157     }
 158
 159     return parent[0];
 160   }
 161
 162
 163   public static boolean processDependenciesInDependencyManagement(@NotNull MavenDomProjectModel projectDom,
 164                                                                   @NotNull final Processor<MavenDomDependencies> processor,
 165                                                                   @NotNull final Project project) {
 166
 167     Function<MavenDomProfile, MavenDomDependencies> domProfileFunction = new Function<MavenDomProfile, MavenDomDependencies>() {
 168       public MavenDomDependencies fun(MavenDomProfile mavenDomProfile) {
 169         return mavenDomProfile.getDependencyManagement().getDependencies();
 170       }
 171     };
 172     Function<MavenDomProjectModel, MavenDomDependencies> projectDomFunction = new Function<MavenDomProjectModel, MavenDomDependencies>() {
 173       public MavenDomDependencies fun(MavenDomProjectModel mavenDomProjectModel) {
 174         return mavenDomProjectModel.getDependencyManagement().getDependencies();
 175       }
 176     };
 177
 178     return process(projectDom, processor, project, domProfileFunction, projectDomFunction);
 179   }
 180
 181   public static boolean processProperties(@NotNull MavenDomProjectModel projectDom,
 182                                           @NotNull final Processor<MavenDomProperties> processor,
 183                                           @NotNull final Project project) {
 184
 185     Function<MavenDomProfile, MavenDomProperties> domProfileFunction = new Function<MavenDomProfile, MavenDomProperties>() {
 186       public MavenDomProperties fun(MavenDomProfile mavenDomProfile) {
 187         return mavenDomProfile.getProperties();
 188       }
 189     };
 190     Function<MavenDomProjectModel, MavenDomProperties> projectDomFunction = new Function<MavenDomProjectModel, MavenDomProperties>() {
 191       public MavenDomProperties fun(MavenDomProjectModel mavenDomProjectModel) {
 192         return mavenDomProjectModel.getProperties();
 193       }
 194     };
 195
 196     return process(projectDom, processor, project, domProfileFunction, projectDomFunction);
 197   }
 198
 199   public static <T> boolean process(@NotNull MavenDomProjectModel projectDom,
 200                                     @NotNull final Processor<T> processor,
 201                                     @NotNull final Project project,
 202                                     @NotNull final Function<MavenDomProfile, T> domProfileFunction,
 203                                     @NotNull final Function<MavenDomProjectModel, T> projectDomFunction) {
 204
 205     MavenProject mavenProjectOrNull = MavenDomUtil.findProject(projectDom);
 206
 207     if (processSettingsXml(mavenProjectOrNull, processor, project, domProfileFunction)) return true;
 208     if (processProject(projectDom, mavenProjectOrNull, processor, project, domProfileFunction, projectDomFunction)) return true;
 209
 210     return processParentProjectFile(projectDom, processor, project, domProfileFunction, projectDomFunction);
 211   }
 212
 213   private static <T> boolean processParentProjectFile(MavenDomProjectModel projectDom,
 214                                                       final Processor<T> processor,
 215                                                       final Project project,
 216                                                       final Function<MavenDomProfile, T> domProfileFunction,
 217                                                       final Function<MavenDomProjectModel, T> projectDomFunction) {
 218     Boolean aBoolean = new MyMavenParentProjectFileProcessor<Boolean>(project) {
 219       protected Boolean doProcessParent(VirtualFile parentFile) {
 220         MavenDomProjectModel parentProjectDom = MavenDomUtil.getMavenDomProjectModel(project, parentFile);
 221         if (parentProjectDom == null) return false;
 222         MavenProject parentMavenProject = MavenDomUtil.findProject(parentProjectDom);
 223
 224         return processProject(parentProjectDom, parentMavenProject, processor, project, domProfileFunction, projectDomFunction);
 225       }
 226     }.process(projectDom);
 227
 228     return aBoolean == null ? false : aBoolean.booleanValue();
 229   }
 230
 231   private static <T> boolean processSettingsXml(@Nullable MavenProject mavenProject,
 232                                                 @NotNull Processor<T> processor,
 233                                                 @NotNull Project project,
 234                                                 Function<MavenDomProfile, T> domProfileFunction) {
 235     MavenGeneralSettings settings = MavenProjectsManager.getInstance(project).getGeneralSettings();
 236
 237     for (VirtualFile each : settings.getEffectiveSettingsFiles()) {
 238       MavenDomSettingsModel settingsDom = MavenDomUtil.getMavenDomModel(project, each, MavenDomSettingsModel.class);
 239       if (settingsDom == null) continue;
 240
 241       if (processProfiles(settingsDom.getProfiles(), mavenProject, processor, domProfileFunction)) return true;
 242     }
 243     return false;
 244   }
 245
 246   private static <T> boolean processProject(MavenDomProjectModel projectDom,
 247                                             MavenProject mavenProjectOrNull,
 248                                             Processor<T> processor,
 249                                             Project project,
 250                                             Function<MavenDomProfile, T> domProfileFunction,
 251                                             Function<MavenDomProjectModel, T> projectDomFunction) {
 252
 253     if (processProfilesXml(MavenDomUtil.getVirtualFile(projectDom), mavenProjectOrNull, processor, project, domProfileFunction)) {
 254       return true;
 255     }
 256
 257     if (processProfiles(projectDom.getProfiles(), mavenProjectOrNull, processor, domProfileFunction)) return true;
 258
 259     T t = projectDomFunction.fun(projectDom);
 260     return t == null ? false : processor.process(t);
 261   }
 262
 263   private static <T> boolean processProfilesXml(VirtualFile projectFile,
 264                                                 MavenProject mavenProjectOrNull,
 265                                                 Processor<T> processor,
 266                                                 Project project,
 267                                                 Function<MavenDomProfile, T> f) {
 268     VirtualFile profilesFile = MavenUtil.findProfilesXmlFile(projectFile);
 269     if (profilesFile == null) return false;
 270
 271     MavenDomProfiles profiles = MavenDomUtil.getMavenDomProfilesModel(project, profilesFile);
 272     if (profiles == null) return false;
 273
 274     return processProfiles(profiles, mavenProjectOrNull, processor, f);
 275   }
 276
 277   private static <T> boolean processProfiles(MavenDomProfiles profilesDom,
 278                                              MavenProject mavenProjectOrNull,
 279                                              Processor<T> processor,
 280                                              Function<MavenDomProfile, T> f) {
 281     Collection<String> activePropfiles = mavenProjectOrNull == null ? null : mavenProjectOrNull.getActiveProfilesIds();
 282     for (MavenDomProfile each : profilesDom.getProfiles()) {
 283       XmlTag idTag = each.getId().getXmlTag();
 284       if (idTag == null) continue;
 285       if (activePropfiles != null && !activePropfiles.contains(idTag.getValue().getText())) continue;
 286
 287       T t = f.fun(each);
 288       if (t != null && processor.process(t)) return true;
 289     }
 290     return false;
 291   }
 292
 293   private abstract static class MyMavenParentProjectFileProcessor<T> extends MavenParentProjectFileProcessor<Boolean> {
 294     private final Project myProject;
 295
 296     public MyMavenParentProjectFileProcessor(Project project) {
 297       myProject = project;
 298     }
 299
 300     protected VirtualFile findManagedFile(@NotNull MavenId id) {
 301       MavenProject project = MavenProjectsManager.getInstance(myProject).findProject(id);
 302       return project == null ? null : project.getFile();
 303     }
 304
 305     @Nullable
 306     public Boolean process(@NotNull MavenDomProjectModel projectDom) {
 307       MavenDomParent parent = projectDom.getMavenParent();
 308       MavenParentDesc parentDesc = null;
 309       if (DomUtil.hasXml(parent)) {
 310         String parentGroupId = parent.getGroupId().getStringValue();
 311         String parentArtifactId = parent.getArtifactId().getStringValue();
 312         String parentVersion = parent.getVersion().getStringValue();
 313         String parentRelativePath = parent.getRelativePath().getStringValue();
 314         if (StringUtil.isEmptyOrSpaces(parentRelativePath)) parentRelativePath = "../pom.xml";
 315         MavenId parentId = new MavenId(parentGroupId, parentArtifactId, parentVersion);
 316         parentDesc = new MavenParentDesc(parentId, parentRelativePath);
 317       }
 318
 319       return process(MavenProjectsManager.getInstance(myProject).getGeneralSettings(), MavenDomUtil.getVirtualFile(projectDom), parentDesc);
 320     }
 321   }
 322 }