com.lewisd.maven.lint.plugin.RulesSelector Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lint-maven-plugin Show documentation
Generates a report of suspicious/inconsistent POM elements, and optionally fails the build if violations are found.
The newest version!
package com.lewisd.maven.lint.plugin;

import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.lewisd.maven.lint.Rule;
import org.apache.maven.model.PatternSet;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;

import static com.lewisd.maven.lint.plugin.PatternSetUtil.convertGlobsToRegex;

public class RulesSelector {
    private final Set availableRules;

    public RulesSelector(Set availableRules) {
        this.availableRules = availableRules;
    }

    public Set selectRules(String... onlyRunRules) {
        Set ruleNames = Sets.newHashSet(onlyRunRules);
        Set selectedRules = Sets.newHashSet();

        if (ruleNames.contains("all")) {
            selectedRules.addAll(Sets.newHashSet(availableRules));
        } else {
            Set rulesNotMatched = Sets.newHashSet();
            Set rulesMatched = Sets.newHashSet();
            for (String ruleName : ruleNames) {
                for (Rule rule : availableRules) {
                    if (rule.getIdentifier().equals(ruleName)) {
                        selectedRules.add(rule);
                        rulesMatched.add(ruleName);
                        rulesNotMatched.remove(ruleName);
                    } else {
                        if (!rulesMatched.contains(ruleName)) {
                            rulesNotMatched.add(ruleName);
                        }
                    }
                }
            }

            if (!rulesNotMatched.isEmpty()) {
                throw new IllegalArgumentException("unsupported rule(s) " + Joiner.on(",").join(rulesNotMatched));
            }
        }

        return selectedRules;
    }

    public Set selectRules(PatternSet rulePatterns) {

        List excludePatterns = convertGlobsToRegex(rulePatterns.getExcludes());
        List includePatterns = convertGlobsToRegex(rulePatterns.getIncludes());

        Set excludedRules = createRulesFromPattern(excludePatterns);
        Set includedRules = createRulesFromPattern(includePatterns);

        includedRules.removeAll(excludedRules);

        return includedRules;
    }

    public Set selectRules(PatternSet rulePatterns, String... onlyRunRules) {

        PatternSet rulePatternsCopy = new PatternSet();

        if (rulePatterns == null) {
            rulePatternsCopy.setExcludes(new ArrayList());
            rulePatternsCopy.setIncludes(Lists.newArrayList("*"));
        } else {
            if (rulePatterns.getIncludes().isEmpty()) {
                rulePatternsCopy.setIncludes(Lists.newArrayList("*"));
            } else {
                rulePatternsCopy.setIncludes(rulePatterns.getIncludes());
            }

            if (rulePatterns.getExcludes().isEmpty()) {
                rulePatternsCopy.setExcludes(new ArrayList());
            } else {
                rulePatternsCopy.setExcludes(rulePatterns.getExcludes());
            }
        }

        Set rulesByList = selectRules(onlyRunRules);

        return new RulesSelector(rulesByList).selectRules(rulePatternsCopy);
    }

    private Set createRulesFromPattern(List patternList) {
        Set ruleSet = Sets.newHashSet();
        for (Rule rule : availableRules) {
            if (matches(patternList, rule.getIdentifier())) {
                ruleSet.add(rule);
            }
        }
        return ruleSet;
    }

    private boolean matches(List patterns, String identifier) {
        for (Pattern pattern : patterns) {
            if (pattern.matcher(identifier).matches()) {
                return true;
            }
        }
        return false;
    }

}