src/main/java/org/apache/maven/plugins/pmd/ExcludeViolationsFromFile.java

package org.apache.maven.plugins.pmd;

/*
 * 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.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;

import org.apache.commons.lang3.StringUtils;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.pmd.model.Violation;

import net.sourceforge.pmd.RuleViolation;

/**
 * This class contains utility for loading property files, which define which PMD violations
 * from which classes should be ignored and not cause a failure.
 * See property <code>pmd.excludeFromFailureFile</code>.
 *
 * @author Andreas Dangel
 */
public class ExcludeViolationsFromFile implements ExcludeFromFile<Violation>
{
    private Map<String, Set<String>> excludeFromFailureClasses = new HashMap<>();

    @Override
    public void loadExcludeFromFailuresData( final String excludeFromFailureFile )
        throws MojoExecutionException
    {
        if ( StringUtils.isEmpty( excludeFromFailureFile ) )
        {
            return;
        }

        File file = new File( excludeFromFailureFile );
        if ( !file.exists() )
        {
            return;
        }
        final Properties props = new Properties();
        try ( FileInputStream fileInputStream = new FileInputStream( new File( excludeFromFailureFile ) ) )
        {
            props.load( fileInputStream );
        }
        catch ( final IOException e )
        {
            throw new MojoExecutionException( "Cannot load properties file " + excludeFromFailureFile, e );
        }
        for ( final Entry<Object, Object> propEntry : props.entrySet() )
        {
            final Set<String> excludedRuleSet = new HashSet<>();
            final String className = propEntry.getKey().toString();
            final String[] excludedRules = propEntry.getValue().toString().split( "," );
            for ( final String excludedRule : excludedRules )
            {
                excludedRuleSet.add( excludedRule.trim() );
            }
            excludeFromFailureClasses.put( className, excludedRuleSet );
        }
    }

    @Override
    public boolean isExcludedFromFailure( final Violation errorDetail )
    {
        final String className = extractClassName( errorDetail.getViolationPackage(), errorDetail.getViolationClass(),
                errorDetail.getFileName() );
        return isExcludedFromFailure( className, errorDetail.getRule() );
    }

    /**
     * Checks whether the given {@link RuleViolation} is excluded. Note: the exclusions must have been
     * loaded before via {@link #loadExcludeFromFailuresData(String)}.
     *
     * @param errorDetail the violation to check
     * @return <code>true</code> if the violation should be excluded, <code>false</code> otherwise.
     */
    public boolean isExcludedFromFailure( final RuleViolation errorDetail )
    {
        final String className = extractClassName( errorDetail.getPackageName(), errorDetail.getClassName(),
                errorDetail.getFilename() );
        return isExcludedFromFailure( className, errorDetail.getRule().getName() );
    }

    @Override
    public int countExclusions()
    {
        int result = 0;
        for ( Set<String> rules : excludeFromFailureClasses.values() )
        {
            result += rules.size();
        }
        return result;
    }

    private boolean isExcludedFromFailure( String className, String ruleName )
    {
        final Set<String> excludedRuleSet = excludeFromFailureClasses.get( className );
        return excludedRuleSet != null && excludedRuleSet.contains( ruleName );
    }

    private String extractClassName( String packageName, String className, String fullPath )
    {
        // for some reason, some violations don't contain the package name, so we have to guess the full class name
        // this looks like a bug in PMD - at least for UnusedImport rule.
        if ( StringUtils.isNotEmpty( packageName ) && StringUtils.isNotEmpty( className ) )
        {
            return packageName + "." + className;
        }
        else if ( StringUtils.isNotEmpty( packageName ) )
        {
            String fileName = fullPath;
            fileName = fileName.substring( fileName.lastIndexOf( File.separatorChar ) + 1 );
            fileName = fileName.substring( 0, fileName.length() - 5 );
            return packageName + "." + fileName;
        }
        else
        {
            final String fileName = fullPath;
            final int javaIdx = fileName.indexOf( File.separator + "java" + File.separator );
            return fileName.substring( javaIdx >= 0 ? javaIdx + 6 : 0, fileName.length() - 5 ).replace(
                File.separatorChar, '.' );
        }
    }
}