[MENFORCER-458] Move Build-in rules to new API

Moved rules:
 - banDependencyManagementScope
 - banDistributionManagement
 - banDuplicatePomDependencyVersions
 - banDynamicVersions
 - bannedPlugins
 - bannedRepositories
 - evaluateBeanshell
 - reactorModuleConvergence
 - requireActiveProfile
 - requireExplicitDependencyScope
 - requirePluginVersions
 - requirePrerequisite
 - requireProfileIdsExist
 - requireReleaseVersion
 - requireSameVersions
 - requireSnapshotVersion

Author: slawekjaranowski

enforcer-rules/src/main/java/org/apache/maven/enforcer/rules/AbstractStandardEnforcerRule.java

@@ -19,6 +19,8 @@
 package org.apache.maven.enforcer.rules;
 
 import org.apache.maven.enforcer.rule.api.AbstractEnforcerRule;
+import org.apache.maven.model.InputLocation;
+import org.apache.maven.project.MavenProject;
 
 /**
  * Abstract help rule.
@@ -37,4 +39,66 @@ public String getMessage() {
     public void setMessage(String message) {
         this.message = message;
     }
+
+    /**
+     * Returns an identifier of a given project.
+     * @param project the project
+     * @return the identifier of the project in the format {@code <groupId>:<artifactId>:<version>}
+     */
+    private static String getProjectId(MavenProject project) {
+        StringBuilder buffer = new StringBuilder(128);
+
+        buffer.append(
+                (project.getGroupId() != null && project.getGroupId().length() > 0)
+                        ? project.getGroupId()
+                        : "[unknown-group-id]");
+        buffer.append(':');
+        buffer.append(
+                (project.getArtifactId() != null && project.getArtifactId().length() > 0)
+                        ? project.getArtifactId()
+                        : "[unknown-artifact-id]");
+        buffer.append(':');
+        buffer.append(
+                (project.getVersion() != null && project.getVersion().length() > 0)
+                        ? project.getVersion()
+                        : "[unknown-version]");
+
+        return buffer.toString();
+    }
+
+    /**
+     * Creates a string with line/column information for problems originating directly from this POM. Inspired by
+     * {@code o.a.m.model.building.ModelProblemUtils.formatLocation(...)}.
+     *
+     * @param project the current project.
+     * @param location The location which should be formatted, must not be {@code null}.
+     * @return The formatted problem location or an empty string if unknown, never {@code null}.
+     */
+    protected static String formatLocation(MavenProject project, InputLocation location) {
+        StringBuilder buffer = new StringBuilder();
+
+        if (!location.getSource().getModelId().equals(getProjectId(project))) {
+            buffer.append(location.getSource().getModelId());
+
+            if (location.getSource().getLocation().length() > 0) {
+                if (buffer.length() > 0) {
+                    buffer.append(", ");
+                }
+                buffer.append(location.getSource().getLocation());
+            }
+        }
+        if (location.getLineNumber() > 0) {
+            if (buffer.length() > 0) {
+                buffer.append(", ");
+            }
+            buffer.append("line ").append(location.getLineNumber());
+        }
+        if (location.getColumnNumber() > 0) {
+            if (buffer.length() > 0) {
+                buffer.append(", ");
+            }
+            buffer.append("column ").append(location.getColumnNumber());
+        }
+        return buffer.toString();
+    }
 }

enforcer-rules/src/main/java/org/apache/maven/enforcer/rules/AlwaysFail.java

@@ -43,6 +43,6 @@ public void execute() throws EnforcerRuleException {
 
     @Override
     public String toString() {
-        return String.format("AlwaysFail[level=%s, message=%s]", getLevel(), getMessage());
+        return String.format("AlwaysFail[message=%s]", getMessage());
     }
 }

enforcer-rules/src/main/java/org/apache/maven/enforcer/rules/AlwaysPass.java

@@ -40,6 +40,6 @@ public void execute() {
 
     @Override
     public String toString() {
-        return String.format("AlwaysPass[level=%s, message=%s]", getLevel(), getMessage());
+        return String.format("AlwaysPass[message=%s]", getMessage());
     }
 }

enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/BanDependencyManagementScope.java renamed to enforcer-rules/src/main/java/org/apache/maven/enforcer/rules/BanDependencyManagementScope.java

@@ -16,27 +16,28 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.apache.maven.plugins.enforcer;
+package org.apache.maven.enforcer.rules;
+
+import javax.inject.Inject;
+import javax.inject.Named;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
-import org.apache.maven.enforcer.rule.api.EnforcerRule2;
 import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
-import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
 import org.apache.maven.enforcer.rules.utils.ArtifactMatcher;
 import org.apache.maven.model.Dependency;
 import org.apache.maven.model.DependencyManagement;
-import org.apache.maven.plugin.logging.Log;
 import org.apache.maven.project.MavenProject;
-import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
 
 /**
  * This rule bans all scope values except for {@code import} from dependencies within the dependency management.
  * There is a configuration option to ignore certain dependencies in this check.
  */
-public class BanDependencyManagementScope extends AbstractNonCacheableEnforcerRule implements EnforcerRule2 {
+@Named("banDependencyManagementScope")
+public final class BanDependencyManagementScope extends AbstractStandardEnforcerRule {
 
     /**
      * Specify the dependencies that will be ignored. This can be a list of artifacts in the format
@@ -54,40 +55,37 @@ public class BanDependencyManagementScope extends AbstractNonCacheableEnforcerRu
      */
     private boolean checkEffectivePom = false;
 
+    private final MavenProject project;
+
+    @Inject
+    public BanDependencyManagementScope(MavenProject project) {
+        this.project = Objects.requireNonNull(project);
+    }
+
     @Override
-    public void execute(EnforcerRuleHelper helper) throws EnforcerRuleException {
-        Log logger = helper.getLog();
-        MavenProject project;
-        try {
-            project = (MavenProject) helper.evaluate("${project}");
-            if (project == null) {
-                throw new EnforcerRuleException("${project} is null");
-            }
-            // only evaluate local depMgmt, without taking into account inheritance and interpolation
-            DependencyManagement depMgmt = checkEffectivePom
-                    ? project.getModel().getDependencyManagement()
-                    : project.getOriginalModel().getDependencyManagement();
-            if (depMgmt != null && depMgmt.getDependencies() != null) {
-                List<Dependency> violatingDependencies = getViolatingDependencies(logger, depMgmt);
-                if (!violatingDependencies.isEmpty()) {
-                    String message = getMessage();
-                    StringBuilder buf = new StringBuilder();
-                    if (message == null) {
-                        message = "Scope other than 'import' is not allowed in 'dependencyManagement'";
-                    }
-                    buf.append(message + System.lineSeparator());
-                    for (Dependency violatingDependency : violatingDependencies) {
-                        buf.append(getErrorMessage(project, violatingDependency));
-                    }
-                    throw new EnforcerRuleException(buf.toString());
+    public void execute() throws EnforcerRuleException {
+        // only evaluate local depMgmt, without taking into account inheritance and interpolation
+        DependencyManagement depMgmt = checkEffectivePom
+                ? project.getModel().getDependencyManagement()
+                : project.getOriginalModel().getDependencyManagement();
+        if (depMgmt != null && depMgmt.getDependencies() != null) {
+            List<Dependency> violatingDependencies = getViolatingDependencies(depMgmt);
+            if (!violatingDependencies.isEmpty()) {
+                String message = getMessage();
+                StringBuilder buf = new StringBuilder();
+                if (message == null) {
+                    message = "Scope other than 'import' is not allowed in 'dependencyManagement'";
+                }
+                buf.append(message + System.lineSeparator());
+                for (Dependency violatingDependency : violatingDependencies) {
+                    buf.append(getErrorMessage(project, violatingDependency));
                 }
+                throw new EnforcerRuleException(buf.toString());
             }
-        } catch (ExpressionEvaluationException e) {
-            throw new EnforcerRuleException("Cannot resolve expression: " + e.getCause(), e);
         }
     }
 
-    protected List<Dependency> getViolatingDependencies(Log logger, DependencyManagement depMgmt) {
+    protected List<Dependency> getViolatingDependencies(DependencyManagement depMgmt) {
         final ArtifactMatcher excludesMatcher;
         if (excludes != null) {
             excludesMatcher = new ArtifactMatcher(excludes, Collections.emptyList());
@@ -98,7 +96,8 @@ protected List<Dependency> getViolatingDependencies(Log logger, DependencyManage
         for (Dependency dependency : depMgmt.getDependencies()) {
             if (dependency.getScope() != null && !"import".equals(dependency.getScope())) {
                 if (excludesMatcher != null && excludesMatcher.match(dependency)) {
-                    logger.debug("Skipping excluded dependency " + dependency + " with scope " + dependency.getScope());
+                    getLog().debug("Skipping excluded dependency " + dependency + " with scope "
+                            + dependency.getScope());
                     continue;
                 }
                 violatingDependencies.add(dependency);
@@ -118,7 +117,10 @@ public void setExcludes(List<String> theExcludes) {
         this.excludes = theExcludes;
     }
 
-    public void setCheckEffectivePom(boolean checkEffectivePom) {
-        this.checkEffectivePom = checkEffectivePom;
+    @Override
+    public String toString() {
+        return String.format(
+                "BanDependencyManagementScope[message=%s, excludes=%s, checkEffectivePom=%b]",
+                getMessage(), excludes, checkEffectivePom);
     }
 }

enforcer-rules/src/main/java/org/apache/maven/enforcer/rules/BanDistributionManagement.java

@@ -0,0 +1,159 @@
+/*
+ * 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.enforcer.rules;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import java.util.Objects;
+
+import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
+import org.apache.maven.model.DistributionManagement;
+import org.apache.maven.project.MavenProject;
+
+/**
+ * This rule will check if a pom contains a <code>distributionManagement</code> part. This should be by best practice
+ * only defined once. It could happen that you like to check the parent as well. This can be activated by using the
+ * <code>ignoreParent</code> which is by default turned off (<code>true</code>) which means not to check the parent.
+ *
+ * @author Karl Heinz Marbaise
+ * @since 1.4
+ */
+@Named("banDistributionManagement")
+public final class BanDistributionManagement extends AbstractStandardEnforcerRule {
+
+    /**
+     * Allow using a repository entry in the distributionManagement area.
+     */
+    private boolean allowRepository = false;
+
+    /**
+     * Allow snapshotRepository entry in the distributionManagement area.
+     */
+    private boolean allowSnapshotRepository = false;
+
+    /**
+     * Allow site entry in the distributionManagement area.
+     */
+    private boolean allowSite = false;
+
+    private final MavenProject project;
+
+    @Inject
+    public BanDistributionManagement(MavenProject project) {
+        this.project = Objects.requireNonNull(project);
+    }
+
+    @Override
+    public void execute() throws EnforcerRuleException {
+
+        if (project.isExecutionRoot()) {
+            if (project.getParent() == null) {
+                // Does it make sense to check something? If yes please make a JIRA ticket for it.
+                getLog().debug("We have no parent and in the root of a build we don't check anything,");
+                getLog().debug("because that is the location where we defined maven-enforcer-plugin.");
+            } else {
+                getLog().debug("We are in the root of the execution and we have a parent.");
+
+                DistributionManagementCheck check = new DistributionManagementCheck(project);
+                check.execute(isAllowRepository(), isAllowSnapshotRepository(), isAllowSite());
+            }
+        } else {
+            getLog().debug("We are in a deeper level.");
+            DistributionManagementCheck check = new DistributionManagementCheck(project);
+            check.execute(isAllowRepository(), isAllowSnapshotRepository(), isAllowSite());
+        }
+    }
+
+    public boolean isAllowRepository() {
+        return allowRepository;
+    }
+
+    public void setAllowRepository(boolean allowRepository) {
+        this.allowRepository = allowRepository;
+    }
+
+    public boolean isAllowSnapshotRepository() {
+        return allowSnapshotRepository;
+    }
+
+    public void setAllowSnapshotRepository(boolean allowSnapshotRepository) {
+        this.allowSnapshotRepository = allowSnapshotRepository;
+    }
+
+    public boolean isAllowSite() {
+        return allowSite;
+    }
+
+    public void setAllowSite(boolean allowSite) {
+        this.allowSite = allowSite;
+    }
+
+    private static class DistributionManagementCheck {
+        private DistributionManagement distributionManagement;
+
+        DistributionManagementCheck(MavenProject project) {
+            this.distributionManagement = project.getOriginalModel().getDistributionManagement();
+        }
+
+        public void execute(boolean isAllowRepository, boolean isAllowSnapshotRepository, boolean isAllowSite)
+                throws EnforcerRuleException {
+            if (hasDistributionManagement()) {
+                if (!isAllowRepository && hasRepository()) {
+                    throw new EnforcerRuleException("You have defined a repository in distributionManagement.");
+                } else if (!isAllowSnapshotRepository && hasSnapshotRepository()) {
+                    throw new EnforcerRuleException("You have defined a snapshotRepository in distributionManagement.");
+                } else if (!isAllowSite && hasSite()) {
+                    throw new EnforcerRuleException("You have defined a site in distributionManagement.");
+                }
+            }
+        }
+
+        private boolean hasRepository() {
+            return getDistributionManagement().getRepository() != null;
+        }
+
+        public DistributionManagement getDistributionManagement() {
+            return distributionManagement;
+        }
+
+        public void setDistributionManagement(DistributionManagement distributionManagement) {
+            this.distributionManagement = distributionManagement;
+        }
+
+        private boolean hasSnapshotRepository() {
+            return getDistributionManagement().getSnapshotRepository() != null;
+        }
+
+        private boolean hasSite() {
+            return getDistributionManagement().getSite() != null;
+        }
+
+        private boolean hasDistributionManagement() {
+            return getDistributionManagement() != null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "BanDistributionManagement[allowRepository=%b, allowSnapshotRepository=%b, allowSite=%b]",
+                allowRepository, allowSnapshotRepository, allowSite);
+    }
+}