View Javadoc

1   package org.apache.maven.plugins.enforcer;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import java.util.ArrayList;
23  import java.util.Collection;
24  import java.util.HashSet;
25  import java.util.LinkedHashMap;
26  import java.util.List;
27  import java.util.Map;
28  import java.util.Set;
29  import java.util.regex.Pattern;
30  
31  import org.apache.maven.artifact.Artifact;
32  import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
33  import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
34  import org.apache.maven.project.MavenProject;
35  import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
36  
37  /**
38   * 
39   * @author Robert Scholte
40   * @since 1.3
41   */
42  public class RequireSameVersions
43      extends AbstractNonCacheableEnforcerRule
44  {
45      private boolean uniqueVersions;
46  
47      private Set<String> dependencies = new HashSet<String>();
48  
49      private Set<String> plugins = new HashSet<String>();
50  
51      private Set<String> buildPlugins = new HashSet<String>();
52  
53      private Set<String> reportPlugins = new HashSet<String>();
54  
55      public void execute( EnforcerRuleHelper helper )
56          throws EnforcerRuleException
57      {
58          // get the project
59          MavenProject project = null;
60          try
61          {
62              project = (MavenProject) helper.evaluate( "${project}" );
63          }
64          catch ( ExpressionEvaluationException eee )
65          {
66              throw new EnforcerRuleException( "Unable to retrieve the MavenProject: ", eee );
67          }
68  
69          // consider including profile based artifacts
70          Map<String, List<String>> versionMembers = new LinkedHashMap<String, List<String>>();
71  
72          Set<String> buildPluginSet = new HashSet<String>( buildPlugins );
73          buildPluginSet.addAll( plugins );
74          Set<String> reportPluginSet = new HashSet<String>( reportPlugins );
75          reportPluginSet.addAll( plugins );
76  
77          versionMembers.putAll( collectVersionMembers( project.getArtifacts(), dependencies, " (dependency)" ) );
78          versionMembers.putAll( collectVersionMembers( project.getPluginArtifacts(), buildPlugins, " (buildPlugin)" ) );
79          versionMembers.putAll( collectVersionMembers( project.getReportArtifacts(), reportPlugins, " (reportPlugin)" ) );
80  
81          if ( versionMembers.size() > 1 )
82          {
83              StringBuilder builder = new StringBuilder( "Found entries with different versions\n" );
84              for ( Map.Entry<String, List<String>> entry : versionMembers.entrySet() )
85              {
86                  builder.append( "Entries with version " ).append( entry.getKey() ).append( '\n' );
87                  for ( String conflictId : entry.getValue() )
88                  {
89                      builder.append( "- " ).append( conflictId ).append( '\n' );
90                  }
91              }
92              throw new EnforcerRuleException( builder.toString() );
93          }
94      }
95  
96      private Map<String, List<String>> collectVersionMembers( Set<Artifact> artifacts, Collection<String> patterns,
97                                                               String source )
98      {
99          Map<String, List<String>> versionMembers = new LinkedHashMap<String, List<String>>();
100         
101         List<Pattern> regExs = new ArrayList<Pattern>();
102         for ( String pattern : patterns )
103         {
104             String regex = pattern.replace( ".", "\\." ).replace( "*", ".*" ).replace( ":", "\\:" ).replace( '?', '.' );
105 
106             // pattern is groupId[:artifactId[:type[:classifier]]]
107             regExs.add( Pattern.compile( regex  + "(\\:.+)?" ) );
108         }
109         
110         for ( Artifact artifact : artifacts )
111         {
112             for ( Pattern regEx: regExs )
113             {
114                 if ( regEx.matcher( artifact.getDependencyConflictId() ).matches() )
115                 {
116                     String version = uniqueVersions ? artifact.getVersion() : artifact.getBaseVersion();
117                     if ( !versionMembers.containsKey( version ) )
118                     {
119                         versionMembers.put( version, new ArrayList<String>() );
120                     }
121                     versionMembers.get( version ).add( artifact.getDependencyConflictId() + source );
122                 }
123             }
124         }
125         return versionMembers;
126     }
127 
128 }