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

/*
 * 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.
 */
package org.apache.maven.plugins.pmd;

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 net.sourceforge.pmd.reporting.RuleViolation;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.pmd.model.Violation;

/**
 * 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 (excludeFromFailureFile == null || excludeFromFailureFile.isEmpty()) {
            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 Map<String, String> additionalInfo = errorDetail.getAdditionalInfo();
        final String className = extractClassName(
                additionalInfo.get(RuleViolation.PACKAGE_NAME),
                additionalInfo.get(RuleViolation.CLASS_NAME),
                errorDetail.getFileId().getAbsolutePath());
        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 (packageName != null && !packageName.isEmpty() && className != null && !className.isEmpty()) {
            return packageName + "." + className;
        } else if (packageName != null && !packageName.isEmpty()) {
            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, '.');
        }
    }
}