package org.apache.maven.plugins.enforcer;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *  http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
  import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
  import org.apache.maven.artifact.versioning.VersionRange;
  import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
  import org.apache.maven.plugin.logging.Log;
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * This rule checks that lists of dependencies are not included.
   *
   * @author <a href="mailto:brianf@apache.org">Brian Fox</a>
   * @version $Id: BannedDependencies.java 1345332 2012-06-01 20:14:13Z rfscholte $
   */
  public class BannedDependencies
      extends AbstractBanDependencies
  {
  
      /**
       * Specify the banned dependencies. This can be a list of artifacts in the format <code>groupId[:artifactId][:version]</code>.
       * Any of the sections can be a wildcard by using '*' (ie group:*:1.0) <br>
       * The rule will fail if any dependency matches any exclude, unless it also matches an include rule.
       */
      public List<String> excludes = null;
  
      /**
       * Specify the allowed dependencies. This can be a list of artifacts in the format <code>groupId[:artifactId][:version]</code>.
       * Any of the sections can be a wildcard by using '*' (ie group:*:1.0) <br>
       * Includes override the exclude rules. It is meant to allow wide exclusion rules with wildcards and still allow a
       * smaller set of includes. <br>
       * For example, to ban all xerces except xerces-api -> exclude "xerces", include "xerces:xerces-api"
       */
      public List<String> includes = null;
  
  
      /**
       * {@inheritDoc}
       */
      protected Set<Artifact> checkDependencies( Set<Artifact> theDependencies, Log log )
          throws EnforcerRuleException
      {
          Set<Artifact> excluded = checkDependencies( theDependencies, excludes );
  
          // anything specifically included should be removed
          // from the ban list.
          if ( excluded != null )
          {
              Set<Artifact> included = checkDependencies( theDependencies, includes );
              if ( included != null )
              {
                  excluded.removeAll( included );
              }
          }
          return excluded;
  
      }
  
      /**
       * Checks the set of dependencies against the list of patterns.
       *
       * @param thePatterns the patterns
       * @param dependencies the dependencies
       * @return a set containing artifacts matching one of the patterns or <code>null</code>
       * @throws EnforcerRuleException the enforcer rule exception
       */
      private Set<Artifact> checkDependencies( Set<Artifact> dependencies, List<String> thePatterns )
          throws EnforcerRuleException
      {
          Set<Artifact> foundMatches = null;
  
          if ( thePatterns != null && thePatterns.size() > 0 )
          {
  
              for ( String pattern : thePatterns )
             {
 
                 String[] subStrings = pattern.split( ":" );
                 subStrings = StringUtils.stripAll( subStrings );
 
                 for ( Artifact artifact : dependencies )
                 {
                     if ( compareDependency( subStrings, artifact ) )
                     {
                         // only create if needed
                         if ( foundMatches == null )
                         {
                             foundMatches = new HashSet<Artifact>();
                         }
                         foundMatches.add( artifact );
                     }
                 }
             }
         }
         return foundMatches;
     }
 
     /**
      * Compares the parsed array of substrings against the artifact.
      * The pattern should follow the format "groupId:artifactId:version:type:scope"
      *
      * @param pattern the array of patterns
      * @param artifact the artifact
      * @return <code>true</code> if the artifact matches one of the patterns
      * @throws EnforcerRuleException the enforcer rule exception
      */
     protected boolean compareDependency( String[] pattern, Artifact artifact )
         throws EnforcerRuleException
     {
 
         boolean result = false;
         if ( pattern.length > 0 )
         {
             result = pattern[0].equals( "*" ) || artifact.getGroupId().equals( pattern[0] );
         }
 
         if ( result && pattern.length > 1 )
         {
             result = pattern[1].equals( "*" ) || artifact.getArtifactId().equals( pattern[1] );
         }
 
         if ( result && pattern.length > 2 )
         {
             // short circuit if the versions are exactly the same
             if ( pattern[2].equals( "*" ) || artifact.getVersion().equals( pattern[2] ) )
             {
                 result = true;
             }
             else
             {
                 try
                 {
                     result =
                         AbstractVersionEnforcer.containsVersion( VersionRange.createFromVersionSpec( pattern[2] ),
                                                                  new DefaultArtifactVersion( artifact.getBaseVersion() ) );
                 }
                 catch ( InvalidVersionSpecificationException e )
                 {
                     throw new EnforcerRuleException( "Invalid Version Range: ", e );
                 }
             }
         }
 
         if ( result && pattern.length > 3 )
         {
             String type = artifact.getType();
             if ( type == null || type.equals( "" ) )
             {
                 type = "jar";
             }
             result = pattern[3].equals( "*" ) || type.equals( pattern[3] );
         }
 
         if ( result && pattern.length > 4 )
         {
             String scope = artifact.getScope();
             if ( scope == null || scope.equals( "" ) )
             {
                 scope = "compile";
             }
             result = pattern[4].equals( "*" ) || scope.equals( pattern[4] );
         }
 
         return result;
     }
 
     /**
      * Gets the excludes.
      *
      * @return the excludes
      */
     public List<String> getExcludes()
     {
         return this.excludes;
     }
 
     /**
      * Sets the excludes.
      *
      * @param theExcludes the excludes to set
      */
     public void setExcludes( List<String> theExcludes )
     {
         this.excludes = theExcludes;
     }
 
     /**
      * Gets the includes.
      *
      * @return the includes
      */
     public List<String> getIncludes()
     {
         return this.includes;
     }
 
     /**
      * Sets the includes.
      *
      * @param theIncludes the includes to set
      */
     public void setIncludes( List<String> theIncludes )
     {
         this.includes = theIncludes;
     }
 
 }