true if rule is cacheable
*/
boolean isCacheable();
/**
* Checks if cached result is valid.
*
* @param cachedRule the last cached instance of the rule. This is to be used by the rule to
* potentially determine if the results are still valid (ie if the configuration has been overridden)
*
* @return true if the stored results are valid for the same id.
*/
boolean isResultValid( EnforcerRule cachedRule );
/**
* If the rule is to be cached, this id is used as part of the key. This can allow rules to take parameters
* that allow multiple results of the same rule to be cached.
*
* @return id to be used by the enforcer to determine uniqueness of cache results. The ids only need to be unique
* within a given rule implementation as the full key will be [classname]-[id]
*/
String getCacheId();
}
EnforcerRuleException.java 0000664 0000000 0000000 00000006165 12057112634 0035136 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-api/src/main/java/org/apache/maven/enforcer/rule/api package org.apache.maven.enforcer.rule.api;
/*
* 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.
*/
/**
* An exception occurring during the execution of a rule. Based off of
* EnforcerRuleException, but separated to keep the rule dependencies to a
* minimum.
*
* @author Brian Fox
* @version $Id: EnforcerRuleException.java 805162 2009-08-17 21:48:52Z hboutemy $
*/
public class EnforcerRuleException
extends Exception
{
/** serialVersionUID. */
private static final long serialVersionUID = 1L;
/** The source. */
protected Object source;
/** The long message. */
protected String longMessage;
/**
* Gets the long message.
*
* @return the long message
*/
public String getLongMessage()
{
return longMessage;
}
/**
* Gets the source.
*
* @return the source
*/
public Object getSource()
{
return source;
}
/**
* Construct a new EnforcerRuleException exception providing
* the source and a short and long message.
*
* @param source the source
* @param shortMessage the short message
* @param longMessage the long message
*/
public EnforcerRuleException( Object source, String shortMessage, String longMessage )
{
super( shortMessage );
this.source = source;
this.longMessage = longMessage;
}
/**
* Construct a new EnforcerRuleException exception wrapping
* an underlying Exception and providing a
* message.
*
* @param message the message
* @param cause the cause
*/
public EnforcerRuleException( String message, Exception cause )
{
super( message, cause );
}
/**
* Construct a new EnforcerRuleException exception wrapping
* an underlying Throwable and providing a
* message.
*
* @param message the message
* @param cause the cause
*/
public EnforcerRuleException( String message, Throwable cause )
{
super( message, cause );
}
/**
* Construct a new EnforcerRuleException exception providing
* a message.
*
* @param message the message
*/
public EnforcerRuleException( String message )
{
super( message );
}
} EnforcerRuleHelper.java 0000664 0000000 0000000 00000006370 12057112634 0034415 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-api/src/main/java/org/apache/maven/enforcer/rule/api package org.apache.maven.enforcer.rule.api;
/*
* 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.List;
import java.util.Map;
import org.apache.maven.plugin.logging.Log;
import org.codehaus.plexus.PlexusContainer;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
/**
* This is the interface that all helpers will use. This
* provides access to the log, session and components to the
* rules.
*
* @author Brian Fox
* @version $Id: EnforcerRuleHelper.java 805162 2009-08-17 21:48:52Z hboutemy $
*/
public interface EnforcerRuleHelper
extends ExpressionEvaluator
{
/**
* Gets the log.
*
* @return the log
*/
Log getLog ();
/*
* (non-Javadoc)
*
* @see org.apache.maven.shared.enforcer.rule.api.EnforcerRuleHelper#getRuntimeInformation()
*/
/**
* Gets the component.
*
* @param clazz the clazz
*
* @return the component
*
* @throws ComponentLookupException the component lookup exception
*/
Object getComponent ( Class clazz )
throws ComponentLookupException;
/**
* Gets the component.
*
* @param componentKey the component key
*
* @return the component
*
* @throws ComponentLookupException the component lookup exception
*/
Object getComponent ( String componentKey )
throws ComponentLookupException;
/**
* Gets the component.
*
* @param role the role
* @param roleHint the role hint
*
* @return the component
*
* @throws ComponentLookupException the component lookup exception
*/
Object getComponent ( String role, String roleHint )
throws ComponentLookupException;
/**
* Gets the component map.
*
* @param role the role
*
* @return the component map
*
* @throws ComponentLookupException the component lookup exception
*/
Map getComponentMap ( String role )
throws ComponentLookupException;
/**
* Gets the component list.
*
* @param role the role
*
* @return the component list
*
* @throws ComponentLookupException the component lookup exception
*/
List getComponentList ( String role )
throws ComponentLookupException;
/**
* Gets the container.
*
* @return the container
*/
PlexusContainer getContainer();
}
maven-enforcer-1.0.1/enforcer-api/src/site/ 0000775 0000000 0000000 00000000000 12057112634 0020526 5 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-api/src/site/apt/ 0000775 0000000 0000000 00000000000 12057112634 0021312 5 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-api/src/site/apt/index.apt 0000664 0000000 0000000 00000002336 12057112634 0023133 0 ustar 00root root 0000000 0000000 ~~ 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.
------
Introduction
------
Brian Fox
------
Mar 2007
------
Maven Enforcer Rule API - Extending The Loving Iron Fist of Maven\x99
Custom rules are easy to make with the <<true if successful
*/
abstract boolean checkFile( File file );
// return standard error message
/**
* Gets the error msg.
*
* @return the error msg
*/
abstract String getErrorMsg();
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRule#execute(org.apache.maven.enforcer.rule.api.EnforcerRuleHelper)
*/
public void execute( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
if ( !allowNulls && files.length == 0 )
{
throw new EnforcerRuleException( "The file list is empty and Null files are disabled." );
}
ArrayList failures = new ArrayList();
for ( int i = 0; i < files.length; i++ )
{
if ( !allowNulls && files[i] == null )
{
failures.add( files[i] );
}
else if ( !checkFile( files[i] ) )
{
failures.add( files[i] );
}
}
// if anything was found, log it with the optional message.
if ( !failures.isEmpty() )
{
StringBuffer buf = new StringBuffer();
if ( message != null )
{
buf.append( message + "\n" );
}
buf.append( getErrorMsg() );
Iterator iter = failures.iterator();
while ( iter.hasNext() )
{
File file = (File) iter.next();
if ( file != null )
{
buf.append( file.getAbsolutePath() + "\n" );
}
else
{
buf.append( "(an empty filename was given and allowNulls is false)\n" );
}
}
throw new EnforcerRuleException( buf.toString() );
}
}
/**
* If your rule is cacheable, you must return a unique id when parameters or conditions change that would cause the
* result to be different. Multiple cached results are stored based on their id. The easiest way to do this is to
* return a hash computed from the values of your parameters. If your rule is not cacheable, then the result here is
* not important, you may return anything.
*
* @return the cache id
*/
public String getCacheId()
{
return Integer.toString( hashCode( files ) );
}
/**
* Calculates a hash code for the specified array as Arrays.hashCode() would do. Unfortunately, the
* mentioned method is only available for Java 1.5 and later.
*
* @param items The array for which to compute the hash code, may be null.
* @return The hash code for the array.
*/
private static int hashCode( Object[] items )
{
int hash = 0;
if ( items != null )
{
hash = 1;
for ( int i = 0; i < items.length; i++ )
{
Object item = items[i];
hash = 31 * hash + ( item == null ? 0 : item.hashCode() );
}
}
return hash;
}
/**
* This tells the system if the results are cacheable at all. Keep in mind that during forked builds and other
* things, a given rule may be executed more than once for the same project. This means that even things that change
* from project to project may still be cacheable in certain instances.
*
* @return true if rule is cacheable
*/
public boolean isCacheable()
{
return true;
}
/**
* If the rule is cacheable and the same id is found in the cache, the stored results are passed to this method to
* allow double checking of the results. Most of the time this can be done by generating unique ids, but sometimes
* the results of objects returned by the helper need to be queried. You may for example, store certain objects in
* your rule and then query them later.
*
* @param cachedRule the cached rule
* @return true if the stored results are valid for the same id.
*/
public boolean isResultValid( EnforcerRule cachedRule )
{
return true;
}
}
AbstractStandardEnforcerRule.java 0000664 0000000 0000000 00000002160 12057112634 0036735 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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 org.apache.maven.enforcer.rule.api.EnforcerRule;
/**
* The Class AbstractStandardEnforcerRule.
*/
public abstract class AbstractStandardEnforcerRule
implements EnforcerRule
{
/** Specify a friendly message if the rule fails. */
public String message = null;
}
AbstractVersionEnforcer.java 0000664 0000000 0000000 00000016165 12057112634 0036004 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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.Iterator;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
import org.apache.maven.artifact.versioning.Restriction;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.enforcer.rule.api.EnforcerRule;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.logging.Log;
import org.codehaus.plexus.util.StringUtils;
/**
* Contains the common code to compare a version against a version range.
*
* @author Brian Fox
* @version $Id: AbstractVersionEnforcer.java 805190 2009-08-17 22:30:49Z hboutemy $
*/
public abstract class AbstractVersionEnforcer
extends AbstractStandardEnforcerRule
{
/**
* Specify the required version. Some examples are:
* 2.0.4 Version 2.0.4 and higher (different from Maven meaning)[2.0,2.1) Versions 2.0 (included) to 2.1 (not included)[2.0,2.1] Versions 2.0 to 2.1 (both included)[2.0.5,) Versions 2.0.5 and higher(,2.0.5],[2.1.1,) Versions up to 2.0.5 (included) and 2.1.1 or highergroupId[:artifactId][:version].
* Any of the sections can be a wildcard by using '*' (ie group:*:1.0) groupId[:artifactId][:version].
* Any of the sections can be a wildcard by using '*' (ie group:*:1.0) null
* @throws EnforcerRuleException the enforcer rule exception
*/
private Set checkDependencies( Set dependencies, List thePatterns )
throws EnforcerRuleException
{
Set foundMatches = null;
if ( thePatterns != null && thePatterns.size() > 0 )
{
Iterator iter = thePatterns.iterator();
while ( iter.hasNext() )
{
String pattern = (String) iter.next();
String[] subStrings = pattern.split( ":" );
subStrings = StringUtils.stripAll( subStrings );
Iterator dependencyIter = dependencies.iterator();
while ( dependencyIter.hasNext() )
{
Artifact artifact = (Artifact) dependencyIter.next();
if ( compareDependency( subStrings, artifact ) )
{
// only create if needed
if ( foundMatches == null )
{
foundMatches = new HashSet();
}
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 true 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 getExcludes()
{
return this.excludes;
}
/**
* Sets the excludes.
*
* @param theExcludes the excludes to set
*/
public void setExcludes( List theExcludes )
{
this.excludes = theExcludes;
}
/**
* Gets the includes.
*
* @return the includes
*/
public List getIncludes()
{
return this.includes;
}
/**
* Sets the includes.
*
* @param theIncludes the includes to set
*/
public void setIncludes( List theIncludes )
{
this.includes = theIncludes;
}
}
BannedPlugins.java 0000664 0000000 0000000 00000002704 12057112634 0033732 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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.Set;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.project.MavenProject;
/**
* This rule checks that lists of plugins are not included.
*
* @author Marvin Froeder
*/
public class BannedPlugins
extends BannedDependencies
{
protected Set getDependenciesToCheck( MavenProject project )
{
return project.getPluginArtifacts();
}
protected CharSequence getErrorMessage( Artifact artifact )
{
return "Found Banned Plugin: " + artifact.getId() + "\n";
}
}
DefaultEnforcementRuleHelper.java 0000664 0000000 0000000 00000012025 12057112634 0036740 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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.io.File;
import java.util.List;
import java.util.Map;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.plugin.logging.Log;
import org.codehaus.plexus.PlexusContainer;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
/**
* Default implementation of the EnforcementRuleHelper interface. This is used to help retrieve information from the
* session and provide useful elements like the log.
*
* @author Brian Fox
* @version $Id: DefaultEnforcementRuleHelper.java 805190 2009-08-17 22:30:49Z hboutemy $
*/
public class DefaultEnforcementRuleHelper
implements EnforcerRuleHelper
{
/** The log. */
Log log;
/** The evaluator. */
ExpressionEvaluator evaluator;
/** The session. */
MavenSession session;
/** The container. */
PlexusContainer container;
/**
* Instantiates a new default enforcement rule helper.
*
* @param session the session
* @param evaluator the evaluator
* @param log the log
* @param container the container
*/
public DefaultEnforcementRuleHelper( MavenSession session, ExpressionEvaluator evaluator, Log log,
PlexusContainer container )
{
this.evaluator = evaluator;
this.log = log;
this.session = session;
if ( container != null )
{
this.container = container;
}
else
{
this.container = session.getContainer();
}
}
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRuleHelper#getLog()
*/
public Log getLog()
{
return log;
}
/*
* (non-Javadoc)
*
* @see org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator#alignToBaseDirectory(java.io.File)
*/
public File alignToBaseDirectory( File theFile )
{
return evaluator.alignToBaseDirectory( theFile );
}
/*
* (non-Javadoc)
*
* @see org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator#evaluate(java.lang.String)
*/
public Object evaluate( String theExpression )
throws ExpressionEvaluationException
{
return evaluator.evaluate( theExpression );
}
/*
* (non-Javadoc)
*
* @see org.apache.maven.shared.enforcer.rule.api.EnforcerRuleHelper#getRuntimeInformation()
*/
public Object getComponent( Class clazz )
throws ComponentLookupException
{
return getComponent( clazz.getName() );
}
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRuleHelper#lookup(java.lang.String)
*/
public Object getComponent( String theComponentKey )
throws ComponentLookupException
{
return container.lookup( theComponentKey );
}
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRuleHelper#lookup(java.lang.String, java.lang.String)
*/
public Object getComponent( String theRole, String theRoleHint )
throws ComponentLookupException
{
return container.lookup( theRole, theRoleHint );
}
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRuleHelper#lookupList(java.lang.String)
*/
public List getComponentList( String theRole )
throws ComponentLookupException
{
return container.lookupList( theRole );
}
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRuleHelper#lookupMap(java.lang.String)
*/
public Map getComponentMap( String theRole )
throws ComponentLookupException
{
return container.lookupMap( theRole );
}
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRuleHelper#getContainer()
*/
public PlexusContainer getContainer()
{
return container;
}
}
DependencyConvergence.java 0000664 0000000 0000000 00000020411 12057112634 0035431 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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.ArrayList;
import java.util.Collections;
import java.util.List;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactCollector;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.enforcer.rule.api.EnforcerRule;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.plugins.enforcer.utils.DependencyVersionMap;
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.dependency.tree.DependencyNode;
import org.apache.maven.shared.dependency.tree.DependencyTreeBuilder;
import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
import org.codehaus.plexus.i18n.I18N;
/**
* @author Rex Hoffman
*/
public class DependencyConvergence implements EnforcerRule {
private static Log log;
private static I18N i18n;
/**
* Uses the {@link EnforcerRuleHelper} to populate the values of the {@link DependencyTreeBuilder#buildDependencyTree(MavenProject, ArtifactRepository, ArtifactFactory, ArtifactMetadataSource, ArtifactFilter, ArtifactCollector)}
* factory method. true if profile is active
*/
protected boolean isProfileActive( MavenProject project, String profileName )
{
List activeProfiles = project.getActiveProfiles();
if ( activeProfiles != null && !activeProfiles.isEmpty() )
{
for ( Iterator it = activeProfiles.iterator(); it.hasNext(); )
{
Profile profile = (Profile) it.next();
if ( profile.getId().equals( profileName ) )
{
return true;
}
}
}
return false;
}
}
RequireFilesDontExist.java 0000664 0000000 0000000 00000002741 12057112634 0035443 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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.io.File;
/**
* The Class RequireFilesDontExist.
*/
public class RequireFilesDontExist
extends AbstractRequireFiles
{
/*
* (non-Javadoc)
*
* @see org.apache.maven.plugins.enforcer.AbstractRequireFiles#checkFile(java.io.File)
*/
boolean checkFile( File file )
{
//if we get here and the handle is null, treat it as a success
return file == null ? true : !file.exists();
}
/*
* (non-Javadoc)
*
* @see org.apache.maven.plugins.enforcer.AbstractRequireFiles#getErrorMsg()
*/
String getErrorMsg()
{
return "Some files should not exist:\n";
}
}
RequireFilesExist.java 0000664 0000000 0000000 00000002736 12057112634 0034622 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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.io.File;
/**
* The Class RequireFilesExist.
*/
public class RequireFilesExist
extends AbstractRequireFiles
{
/*
* (non-Javadoc)
*
* @see org.apache.maven.plugins.enforcer.AbstractRequireFiles#checkFile(java.io.File)
*/
boolean checkFile( File file )
{
//if we get here and the handle is null, treat it as a success
return file == null ? true : file.exists();
}
/*
* (non-Javadoc)
*
* @see org.apache.maven.plugins.enforcer.AbstractRequireFiles#getErrorMsg()
*/
String getErrorMsg()
{
return "Some required files are missing:\n";
}
}
RequireFilesSize.java 0000664 0000000 0000000 00000010713 12057112634 0034432 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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.io.File;
import org.apache.maven.enforcer.rule.api.EnforcerRule;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
/**
* Rule to validate the main artifact is within certain size constraints.
*
* @author brianf
* @author Roman Stumm
*/
public class RequireFilesSize
extends AbstractRequireFiles
{
/** the max size allowed. */
long maxsize = 10000;
/** the min size allowed. */
long minsize = 0;
/** The error msg. */
private String errorMsg;
/** The log. */
private Log log;
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRule#execute(org.apache.maven.enforcer.rule.api.EnforcerRuleHelper)
*/
public void execute( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
this.log = helper.getLog();
// if the file is already defined, use that. Otherwise get the main artifact.
if ( files.length == 0 )
{
try
{
MavenProject project = (MavenProject) helper.evaluate( "${project}" );
files = new File[1];
files[0] = project.getArtifact().getFile();
super.execute( helper );
}
catch ( ExpressionEvaluationException e )
{
throw new EnforcerRuleException( "Unable to retrieve the project.", e );
}
}
else
{
super.execute( helper );
}
}
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRule#isCacheable()
*/
public boolean isCacheable()
{
return false;
}
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRule#isResultValid(org.apache.maven.enforcer.rule.api.EnforcerRule)
*/
public boolean isResultValid( EnforcerRule cachedRule )
{
return false;
}
/* (non-Javadoc)
* @see org.apache.maven.plugins.enforcer.AbstractRequireFiles#checkFile(java.io.File)
*/
boolean checkFile( File file )
{
if (file == null)
{
//if we get here and it's null, treat it as a success.
return true;
}
// check the file now
if ( file.exists() )
{
long length = file.length();
if ( length < minsize )
{
this.errorMsg = ( file + " size (" + length + ") too small. Min. is " + minsize );
return false;
}
else if ( length > maxsize )
{
this.errorMsg = ( file + " size (" + length + ") too large. Max. is " + maxsize );
return false;
}
else
{
this.log.debug( file +
" size (" +
length +
") is OK (" +
( minsize == maxsize || minsize == 0 ? ( "max. " + maxsize )
: ( "between " + minsize + " and " + maxsize ) ) + " byte)." );
return true;
}
}
else
{
this.errorMsg = ( file + " does not exist!" );
return false;
}
}
/* (non-Javadoc)
* @see org.apache.maven.plugins.enforcer.AbstractRequireFiles#getErrorMsg()
*/
String getErrorMsg()
{
return this.errorMsg;
}
}
RequireJavaVersion.java 0000664 0000000 0000000 00000007526 12057112634 0034774 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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.Arrays;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.lang.SystemUtils;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.plugin.logging.Log;
import org.codehaus.plexus.util.StringUtils;
/**
* This rule checks that the Java version is allowed.
*
* @author Brian Fox
* @version $Id: RequireJavaVersion.java 805190 2009-08-17 22:30:49Z hboutemy $
*/
public class RequireJavaVersion
extends AbstractVersionEnforcer
{
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRule#execute(org.apache.maven.enforcer.rule.api.EnforcerRuleHelper)
*/
public void execute( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
String java_version = SystemUtils.JAVA_VERSION_TRIMMED;
Log log = helper.getLog();
log.debug( "Detected Java String: " + java_version );
java_version = normalizeJDKVersion( java_version );
log.debug( "Normalized Java String: " + java_version );
ArtifactVersion detectedJdkVersion = new DefaultArtifactVersion( java_version );
log.debug( "Parsed Version: Major: " + detectedJdkVersion.getMajorVersion() + " Minor: " +
detectedJdkVersion.getMinorVersion() + " Incremental: " + detectedJdkVersion.getIncrementalVersion() +
" Build: " + detectedJdkVersion.getBuildNumber() + " Qualifier: " + detectedJdkVersion.getQualifier() );
enforceVersion( helper.getLog(), "JDK", version, detectedJdkVersion );
}
/**
* Converts a jdk string from 1.5.0-11b12 to a single 3 digit version like 1.5.0-11
*
* @param theJdkVersion to be converted.
* @return the converted string.
*/
public static String normalizeJDKVersion( String theJdkVersion )
{
theJdkVersion = theJdkVersion.replaceAll( "_|-", "." );
String tokenArray[] = StringUtils.split( theJdkVersion, "." );
List tokens = Arrays.asList( tokenArray );
StringBuffer buffer = new StringBuffer( theJdkVersion.length() );
Iterator iter = tokens.iterator();
for ( int i = 0; i < tokens.size() && i < 4; i++ )
{
String section = (String) iter.next();
section = section.replaceAll( "[^0-9]", "" );
if ( StringUtils.isNotEmpty( section ) )
{
buffer.append( Integer.parseInt( section ) );
if ( i != 2 )
{
buffer.append( '.' );
}
else
{
buffer.append( '-' );
}
}
}
String version = buffer.toString();
version = StringUtils.stripEnd( version, "-" );
return StringUtils.stripEnd( version, "." );
}
}
RequireMavenVersion.java 0000664 0000000 0000000 00000004342 12057112634 0035152 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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 org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.execution.RuntimeInformation;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
/**
* This rule checks that the Maven version is allowed.
*
* @author Brian Fox
* @version $Id: RequireMavenVersion.java 805190 2009-08-17 22:30:49Z hboutemy $
*/
public class RequireMavenVersion
extends AbstractVersionEnforcer
{
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRule#execute(org.apache.maven.enforcer.rule.api.EnforcerRuleHelper)
*/
public void execute( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
try
{
RuntimeInformation rti = (RuntimeInformation) helper.getComponent( RuntimeInformation.class );
ArtifactVersion detectedMavenVersion = rti.getApplicationVersion();
helper.getLog().debug( "Detected Maven Version: " + detectedMavenVersion );
enforceVersion( helper.getLog(), "Maven", this.version, detectedMavenVersion );
}
catch ( ComponentLookupException e )
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
RequireNoRepositories.java 0000664 0000000 0000000 00000016355 12057112634 0035531 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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 org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.model.Model;
import org.apache.maven.model.Repository;
import org.apache.maven.plugins.enforcer.utils.EnforcerRuleUtils;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
/**
* This rule checks that this pom or its parents don't define a repository.
*
* @author Brian Fox
*/
public class RequireNoRepositories
extends AbstractNonCacheableEnforcerRule
{
/**
* Whether to ban non-plugin repositories. By default they are banned.
*/
public boolean banRepositories = true;
/**
* Whether to ban plugin repositories. By default they are banned.
*/
public boolean banPluginRepositories = true;
/**
* Specify explicitly allowed non-plugin repositories. This is a list of ids.
*/
public List allowedRepositories = Collections.EMPTY_LIST;
/**
* Specify explicitly allowed plugin repositories. This is a list of ids.
*/
public List allowedPluginRepositories = Collections.EMPTY_LIST;
/**
* Whether to allow repositories which only resolve snapshots. By default they are banned.
*/
public boolean allowSnapshotRepositories = false;
/**
* Whether to allow plugin repositories which only resolve snapshots. By default they are banned.
*/
public boolean allowSnapshotPluginRepositories = false;
/*
* (non-Javadoc)
* @see
* org.apache.maven.enforcer.rule.api.EnforcerRule#execute(org.apache.maven.enforcer.rule.api.EnforcerRuleHelper)
*/
public void execute( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
EnforcerRuleUtils utils = new EnforcerRuleUtils( helper );
MavenProject project;
try
{
project = (MavenProject) helper.evaluate( "${project}" );
List models =
utils.getModelsRecursively( project.getGroupId(), project.getArtifactId(), project.getVersion(),
new File( project.getBasedir(), "pom.xml" ) );
List badModels = new ArrayList();
StringBuffer newMsg = new StringBuffer();
newMsg.append( "Some poms have repositories defined:\n" );
for ( Iterator i = models.iterator(); i.hasNext(); )
{
Model model = (Model) i.next();
if ( banRepositories )
{
List repos = model.getRepositories();
if ( repos != null && !repos.isEmpty() )
{
List bannedRepos =
findBannedRepositories( repos, allowedRepositories, allowSnapshotRepositories );
if ( !bannedRepos.isEmpty() )
{
badModels.add( model );
newMsg.append(
model.getGroupId() + ":" + model.getArtifactId() + " version:" + model.getVersion()
+ " has repositories " + bannedRepos );
}
}
}
if ( banPluginRepositories )
{
List repos = model.getPluginRepositories();
if ( repos != null && !repos.isEmpty() )
{
List bannedRepos =
findBannedRepositories( repos, allowedPluginRepositories, allowSnapshotPluginRepositories );
if ( !bannedRepos.isEmpty() )
{
badModels.add( model );
newMsg.append(
model.getGroupId() + ":" + model.getArtifactId() + " version:" + model.getVersion()
+ " has plugin repositories " + bannedRepos );
}
}
}
}
// if anything was found, log it then append the
// optional message.
if ( !badModels.isEmpty() )
{
if ( StringUtils.isNotEmpty( message ) )
{
newMsg.append( message );
}
throw new EnforcerRuleException( newMsg.toString() );
}
}
catch ( ExpressionEvaluationException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
catch ( ArtifactResolutionException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
catch ( ArtifactNotFoundException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
catch ( IOException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
catch ( XmlPullParserException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
}
private static List findBannedRepositories( List repos, List allowedRepos, boolean allowSnapshots )
{
List bannedRepos = new ArrayList( allowedRepos.size() );
for ( Iterator i = repos.iterator(); i.hasNext(); )
{
Repository r = (Repository) i.next();
if ( !allowedRepos.contains( r.getId() ) )
{
if ( !allowSnapshots || r.getReleases().isEnabled() )
{
// if we are not allowing snapshots and this repo is enabled for releases
// it is banned. We don't care whether it is enabled for snapshots
// if you define a repo and don't enable it for anything, then we have nothing
// to worry about
bannedRepos.add( r.getId() );
}
}
}
return bannedRepos;
}
}
maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequireOS.java 0000664 0000000 0000000 00000024101 12057112634 0033131 0 ustar 00root root 0000000 0000000 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.Iterator;
import org.apache.maven.enforcer.rule.api.EnforcerRule;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.model.Activation;
import org.apache.maven.model.ActivationOS;
import org.apache.maven.model.Profile;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.profiles.activation.OperatingSystemProfileActivator;
import org.codehaus.plexus.util.Os;
import org.codehaus.plexus.util.StringUtils;
/**
* This rule checks that the OS is allowed by combinations of family, name, version and cpu architecture. The behavior
* is exactly the same as the Maven Os profile activation so the same values are allowed here.
*
* @author Brian Fox
* @version $Id: RequireOS.java 805190 2009-08-17 22:30:49Z hboutemy $
*/
public class RequireOS
extends AbstractStandardEnforcerRule
{
/**
* The OS family type desiredgroup:artifactId.
*/
public List additionalPlugins;
/**
* Plugins to skip for version enforcement. The plugins should be specified in the form:
* group:artifactId. NOTE: This is deprecated, use unCheckedPluginList instead.
* @deprecated
*/
public List unCheckedPlugins;
/**
* Same as unCheckedPlugins but as a comma list to better support properties. Sample form:
* group:artifactId,group2:artifactId2
* @since 1.0-beta-1
*/
public String unCheckedPluginList;
/** The plugin manager. */
private PluginManager pluginManager;
/** The phase to lifecycle map. */
private Map phaseToLifecycleMap;
/** The lifecycles. */
private List lifecycles;
/** The factory. */
ArtifactFactory factory;
/** The resolver. */
ArtifactResolver resolver;
/** The local. */
ArtifactRepository local;
/** The remote repositories. */
List remoteRepositories;
/** The log. */
Log log;
/** The session. */
MavenSession session;
/** The utils. */
EnforcerRuleUtils utils;
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRule#execute(org.apache.maven.enforcer.rule.api.EnforcerRuleHelper)
*/
public void execute( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
log = helper.getLog();
MavenProject project;
try
{
// get the various expressions out of the helper.
project = (MavenProject) helper.evaluate( "${project}" );
LifecycleExecutor life;
life = (LifecycleExecutor) helper.getComponent( LifecycleExecutor.class );
try
{
lifecycles = (List) ReflectionUtils.getValueIncludingSuperclasses( "lifecycles", life );
}
catch (Exception e)
{
log.info( "The requirePluginVersions rule is currently not compatible with Maven3.");
/*
*
* NOTE: If this happens, we're bailing out right away.
*
*
*/
return;
}
session = (MavenSession) helper.evaluate( "${session}" );
pluginManager = (PluginManager) helper.getComponent( PluginManager.class );
factory = (ArtifactFactory) helper.getComponent( ArtifactFactory.class );
resolver = (ArtifactResolver) helper.getComponent( ArtifactResolver.class );
local = (ArtifactRepository) helper.evaluate( "${localRepository}" );
remoteRepositories = project.getRemoteArtifactRepositories();
utils = new EnforcerRuleUtils( helper );
// get all the plugins that are bound to the specified lifecycles
Set allPlugins = getBoundPlugins( life, project, phases );
// insert any additional plugins specified by the user.
allPlugins = addAdditionalPlugins( allPlugins, additionalPlugins );
allPlugins.addAll( getProfilePlugins( project ) );
// pull out any we should skip
allPlugins = (Set) removeUncheckedPlugins( combineUncheckedPlugins( unCheckedPlugins, unCheckedPluginList ), allPlugins );
// there's nothing to do here
if ( allPlugins.isEmpty() )
{
log.info( "No plugin bindings found." );
return;
}
else
{
log.debug( "All Plugins in use: " + allPlugins );
}
// get all the plugins that are mentioned in the pom (and parents)
List pluginWrappers = getAllPluginEntries( project );
// now look for the versions that aren't valid and add to a list.
ArrayList failures = new ArrayList();
Iterator iter = allPlugins.iterator();
while ( iter.hasNext() )
{
Plugin plugin = (Plugin) iter.next();
if ( !hasValidVersionSpecified( helper, plugin, pluginWrappers ) )
{
failures.add( plugin );
}
}
// if anything was found, log it then append the optional message.
if ( !failures.isEmpty() )
{
StringBuffer newMsg = new StringBuffer();
newMsg.append( "Some plugins are missing valid versions:" );
if ( banLatest || banRelease || banSnapshots || banTimestamps )
{
newMsg.append( "(" );
if ( banLatest )
{
newMsg.append( "LATEST " );
}
if ( banRelease )
{
newMsg.append( "RELEASE " );
}
if ( banSnapshots || banTimestamps )
{
newMsg.append( "SNAPSHOT " );
}
newMsg.append( "are not allowed )\n" );
}
iter = failures.iterator();
while ( iter.hasNext() )
{
Plugin plugin = (Plugin) iter.next();
newMsg.append( plugin.getGroupId() );
newMsg.append( ":" );
newMsg.append( plugin.getArtifactId() );
try
{
newMsg.append( ". \tThe version currently in use is " );
Plugin currentPlugin = findCurrentPlugin( plugin, project );
if ( currentPlugin != null )
{
newMsg.append( currentPlugin.getVersion() );
}
else
{
newMsg.append( "unknown" );
}
}
catch ( Exception e )
{
// lots can go wrong here. Don't allow any issues trying to
// determine the issue stop me
log.debug( "Exception while determining plugin Version.", e );
newMsg.append( ". Unable to determine the plugin version." );
}
newMsg.append( "\n" );
}
if ( StringUtils.isNotEmpty( message ) )
{
newMsg.append( message );
}
throw new EnforcerRuleException( newMsg.toString() );
}
}
catch ( ExpressionEvaluationException e )
{
throw new EnforcerRuleException( "Unable to Evaluate an Expression:" + e.getLocalizedMessage() );
}
catch ( ComponentLookupException e )
{
throw new EnforcerRuleException( "Unable to lookup a component:" + e.getLocalizedMessage() );
}
catch ( IllegalAccessException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
catch ( LifecycleExecutionException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
catch ( PluginNotFoundException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
catch ( ArtifactResolutionException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
catch ( ArtifactNotFoundException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
catch ( IOException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
catch ( XmlPullParserException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
catch ( MojoExecutionException e )
{
throw new EnforcerRuleException( e.getLocalizedMessage() );
}
}
/**
* Remove the plugins that the user doesn't want to check.
*
* @param uncheckedPlugins
* @param plugins
* @return
* @throws MojoExecutionException
*/
public Collection removeUncheckedPlugins( Collection uncheckedPlugins, Collection plugins )
throws MojoExecutionException
{
if ( uncheckedPlugins != null && !uncheckedPlugins.isEmpty() )
{
Iterator iter = uncheckedPlugins.iterator();
while ( iter.hasNext() )
{
Plugin plugin = parsePluginString( (String) iter.next(), "UncheckedPlugins" );
plugins.remove( plugin );
}
}
return plugins;
}
/**
* Combines the old Collection with the new comma separated list.
* @param uncheckedPlugins
* @param uncheckedPluginsList
* @return
*/
public Collection combineUncheckedPlugins( Collection uncheckedPlugins, String uncheckedPluginsList )
{
//if the comma list is empty, then there's nothing to do here.
if ( StringUtils.isNotEmpty( uncheckedPluginsList ) )
{
//make sure there is a collection to add to.
if ( uncheckedPlugins == null )
{
uncheckedPlugins = new HashSet();
}
else if (!uncheckedPlugins.isEmpty() && log != null)
{
log.warn( "The parameter 'unCheckedPlugins' is deprecated. Use 'unCheckedPluginList' instead" );
}
uncheckedPlugins.addAll( Arrays.asList( uncheckedPluginsList.split( "," ) ) );
}
return uncheckedPlugins;
}
/**
* Add the additional plugins if they don't exist yet.
*
* @param existing the existing
* @param additional the additional
* @return the sets the
* @throws MojoExecutionException the mojo execution exception
*/
public Set addAdditionalPlugins( Set existing, List additional )
throws MojoExecutionException
{
if ( additional != null )
{
Iterator iter = additional.iterator();
while ( iter.hasNext() )
{
String pluginString = (String) iter.next();
Plugin plugin = parsePluginString( pluginString, "AdditionalPlugins" );
if ( existing == null )
{
existing = new HashSet();
existing.add( plugin );
}
else if ( !existing.contains( plugin ) )
{
existing.add( plugin );
}
}
}
return existing;
}
/**
* Helper method to parse and inject a Plugin.
*
* @param pluginString
* @return
* @throws MojoExecutionException
*/
protected Plugin parsePluginString( String pluginString, String field )
throws MojoExecutionException
{
if ( pluginString != null )
{
String[] pluginStrings = pluginString.split( ":" );
if ( pluginStrings.length == 2 )
{
Plugin plugin = new Plugin();
plugin.setGroupId( StringUtils.strip( pluginStrings[0] ) );
plugin.setArtifactId( StringUtils.strip( pluginStrings[1] ) );
return plugin;
}
else
{
throw new MojoExecutionException( "Invalid " + field + " string: " + pluginString );
}
}
else
{
throw new MojoExecutionException( "Invalid " + field + " string: " + pluginString );
}
}
/**
* Finds the plugins that are listed in active profiles.
*
* @param project the project
* @return the profile plugins
*/
public Set getProfilePlugins( MavenProject project )
{
Set result = new HashSet();
List profiles = project.getActiveProfiles();
if ( profiles != null && !profiles.isEmpty() )
{
Iterator iter = profiles.iterator();
while ( iter.hasNext() )
{
Profile p = (Profile) iter.next();
BuildBase b = p.getBuild();
if ( b != null )
{
List plugins = b.getPlugins();
if ( plugins != null )
{
result.addAll( plugins );
}
}
}
}
return result;
}
/**
* Given a plugin, this will retrieve the matching plugin artifact from the model.
*
* @param plugin plugin to lookup
* @param project project to search
* @return matching plugin, null if not found.
*/
protected Plugin findCurrentPlugin( Plugin plugin, MavenProject project )
{
Plugin found = null;
try
{
Model model = project.getModel();
Map plugins = model.getBuild().getPluginsAsMap();
found = (Plugin) plugins.get( plugin.getKey() );
}
catch ( NullPointerException e )
{
// nothing to do here
}
if ( found == null )
{
found = resolvePlugin( plugin, project );
}
return found;
}
/**
* Resolve plugin.
*
* @param plugin the plugin
* @param project the project
* @return the plugin
*/
protected Plugin resolvePlugin( Plugin plugin, MavenProject project )
{
List pluginRepositories = project.getPluginArtifactRepositories();
Artifact artifact =
factory.createPluginArtifact( plugin.getGroupId(), plugin.getArtifactId(),
VersionRange.createFromVersion( "LATEST" ) );
try
{
this.resolver.resolve( artifact, pluginRepositories, this.local );
plugin.setVersion( artifact.getVersion() );
}
catch ( ArtifactResolutionException e )
{
}
catch ( ArtifactNotFoundException e )
{
}
return plugin;
}
/**
* Gets the plugins that are bound to the defined phases. This does not find plugins bound in the pom to a phase
* later than the plugin is executing.
*
* @param life the life
* @param project the project
* @param thePhases the the phases
* @return the bound plugins
* @throws PluginNotFoundException the plugin not found exception
* @throws LifecycleExecutionException the lifecycle execution exception
* @throws IllegalAccessException the illegal access exception
*/
protected Set getBoundPlugins( LifecycleExecutor life, MavenProject project, String thePhases )
throws PluginNotFoundException, LifecycleExecutionException, IllegalAccessException
{
Set allPlugins = new HashSet();
// lookup the bindings for all the passed in phases
String[] lifecyclePhases = thePhases.split( "," );
for ( int i = 0; i < lifecyclePhases.length; i++ )
{
String lifecyclePhase = lifecyclePhases[i];
if ( StringUtils.isNotEmpty( lifecyclePhase ) )
{
try
{
Lifecycle lifecycle = getLifecycleForPhase( lifecyclePhase );
allPlugins.addAll( getAllPlugins( project, lifecycle ) );
}
catch ( BuildFailureException e )
{
// i'm going to swallow this because the
// user may have declared a phase that
// doesn't exist for every module.
}
}
}
return allPlugins;
}
/*
* Checks to see if the version is specified for the plugin. Can optionally ban "RELEASE" or "LATEST" even if
* specified.
*/
/**
* Checks for valid version specified.
*
* @param helper the helper
* @param source the source
* @param pluginWrappers the plugins
* @return true, if successful
*/
protected boolean hasValidVersionSpecified( EnforcerRuleHelper helper, Plugin source, List pluginWrappers )
{
boolean found = false;
boolean status = false;
Iterator iter = pluginWrappers.iterator();
while ( iter.hasNext() )
{
// find the matching plugin entry
PluginWrapper plugin = (PluginWrapper) iter.next();
if ( source.getArtifactId().equals( plugin.getArtifactId() )
&& source.getGroupId().equals( plugin.getGroupId() ) )
{
found = true;
// found the entry. now see if the version is specified
String version = plugin.getVersion();
try
{
version = (String) helper.evaluate( version );
}
catch ( ExpressionEvaluationException e )
{
return false;
}
if ( StringUtils.isNotEmpty( version ) && !StringUtils.isWhitespace( version ) )
{
if ( banRelease && version.equals( "RELEASE" ) )
{
return false;
}
if ( banLatest && version.equals( "LATEST" ) )
{
return false;
}
if ( banSnapshots && isSnapshot( version ) )
{
return false;
}
// the version was specified and not
// banned. It's ok. Keep looking through the list to make
// sure it's not using a banned version somewhere else.
status = true;
if ( !banRelease && !banLatest && !banSnapshots )
{
// no need to keep looking
break;
}
}
}
}
if ( !found )
{
log.debug( "plugin " + source.getGroupId() + ":" + source.getArtifactId() + " not found" );
}
return status;
}
/**
* Checks if is snapshot.
*
* @param baseVersion the base version
* @return true, if is snapshot
*/
protected boolean isSnapshot( String baseVersion )
{
if ( banTimestamps )
{
return Artifact.VERSION_FILE_PATTERN.matcher( baseVersion ).matches()
|| baseVersion.endsWith( Artifact.SNAPSHOT_VERSION );
}
else
{
return baseVersion.endsWith( Artifact.SNAPSHOT_VERSION );
}
}
/*
* Uses borrowed lifecycle code to get a list of all plugins bound to the lifecycle.
*/
/**
* Gets the all plugins.
*
* @param project the project
* @param lifecycle the lifecycle
* @return the all plugins
* @throws PluginNotFoundException the plugin not found exception
* @throws LifecycleExecutionException the lifecycle execution exception
*/
private Set getAllPlugins( MavenProject project, Lifecycle lifecycle )
throws PluginNotFoundException, LifecycleExecutionException
{
HashSet plugins = new HashSet();
// first, bind those associated with the packaging
Map mappings = findMappingsForLifecycle( project, lifecycle );
Iterator iter = mappings.entrySet().iterator();
while ( iter.hasNext() )
{
Entry entry = (Entry) iter.next();
String value = (String) entry.getValue();
String tokens[] = value.split( ":" );
Plugin plugin = new Plugin();
plugin.setGroupId( tokens[0] );
plugin.setArtifactId( tokens[1] );
plugins.add( plugin );
}
List mojos = findOptionalMojosForLifecycle( project, lifecycle );
iter = mojos.iterator();
while ( iter.hasNext() )
{
String value = (String) iter.next();
String tokens[] = value.split( ":" );
Plugin plugin = new Plugin();
plugin.setGroupId( tokens[0] );
plugin.setArtifactId( tokens[1] );
plugins.add( plugin );
}
for ( Iterator i = project.getBuildPlugins().iterator(); i.hasNext(); )
{
plugins.add( i.next() );
}
return plugins;
}
/*
* NOTE: All the code following this point was scooped from the DefaultLifecycleExecutor. There must be a better way
* but for now it should work.
*/
/**
* Gets the phase to lifecycle map.
*
* @return the phase to lifecycle map
* @throws LifecycleExecutionException the lifecycle execution exception
*/
public Map getPhaseToLifecycleMap()
throws LifecycleExecutionException
{
if ( phaseToLifecycleMap == null )
{
phaseToLifecycleMap = new HashMap();
for ( Iterator i = lifecycles.iterator(); i.hasNext(); )
{
Lifecycle lifecycle = (Lifecycle) i.next();
for ( Iterator p = lifecycle.getPhases().iterator(); p.hasNext(); )
{
String phase = (String) p.next();
if ( phaseToLifecycleMap.containsKey( phase ) )
{
Lifecycle prevLifecycle = (Lifecycle) phaseToLifecycleMap.get( phase );
throw new LifecycleExecutionException( "Phase '" + phase
+ "' is defined in more than one lifecycle: '" + lifecycle.getId() + "' and '"
+ prevLifecycle.getId() + "'" );
}
else
{
phaseToLifecycleMap.put( phase, lifecycle );
}
}
}
}
return phaseToLifecycleMap;
}
/**
* Gets the lifecycle for phase.
*
* @param phase the phase
* @return the lifecycle for phase
* @throws BuildFailureException the build failure exception
* @throws LifecycleExecutionException the lifecycle execution exception
*/
private Lifecycle getLifecycleForPhase( String phase )
throws BuildFailureException, LifecycleExecutionException
{
Lifecycle lifecycle = (Lifecycle) getPhaseToLifecycleMap().get( phase );
if ( lifecycle == null )
{
throw new BuildFailureException( "Unable to find lifecycle for phase '" + phase + "'" );
}
return lifecycle;
}
/**
* Find mappings for lifecycle.
*
* @param project the project
* @param lifecycle the lifecycle
* @return the map
* @throws LifecycleExecutionException the lifecycle execution exception
* @throws PluginNotFoundException the plugin not found exception
*/
private Map findMappingsForLifecycle( MavenProject project, Lifecycle lifecycle )
throws LifecycleExecutionException, PluginNotFoundException
{
String packaging = project.getPackaging();
Map mappings = null;
LifecycleMapping m =
(LifecycleMapping) findExtension( project, LifecycleMapping.ROLE, packaging, session.getSettings(),
session.getLocalRepository() );
if ( m != null )
{
mappings = m.getPhases( lifecycle.getId() );
}
Map defaultMappings = lifecycle.getDefaultPhases();
if ( mappings == null )
{
try
{
m = (LifecycleMapping) session.lookup( LifecycleMapping.ROLE, packaging );
mappings = m.getPhases( lifecycle.getId() );
}
catch ( ComponentLookupException e )
{
if ( defaultMappings == null )
{
throw new LifecycleExecutionException( "Cannot find lifecycle mapping for packaging: \'"
+ packaging + "\'.", e );
}
}
}
if ( mappings == null )
{
if ( defaultMappings == null )
{
throw new LifecycleExecutionException( "Cannot find lifecycle mapping for packaging: \'" + packaging
+ "\', and there is no default" );
}
else
{
mappings = defaultMappings;
}
}
return mappings;
}
/**
* Find optional mojos for lifecycle.
*
* @param project the project
* @param lifecycle the lifecycle
* @return the list
* @throws LifecycleExecutionException the lifecycle execution exception
* @throws PluginNotFoundException the plugin not found exception
*/
private List findOptionalMojosForLifecycle( MavenProject project, Lifecycle lifecycle )
throws LifecycleExecutionException, PluginNotFoundException
{
String packaging = project.getPackaging();
List optionalMojos = null;
LifecycleMapping m =
(LifecycleMapping) findExtension( project, LifecycleMapping.ROLE, packaging, session.getSettings(),
session.getLocalRepository() );
if ( m != null )
{
optionalMojos = m.getOptionalMojos( lifecycle.getId() );
}
if ( optionalMojos == null )
{
try
{
m = (LifecycleMapping) session.lookup( LifecycleMapping.ROLE, packaging );
optionalMojos = m.getOptionalMojos( lifecycle.getId() );
}
catch ( ComponentLookupException e )
{
log.debug( "Error looking up lifecycle mapping to retrieve optional mojos. Lifecycle ID: "
+ lifecycle.getId() + ". Error: " + e.getMessage(), e );
}
}
if ( optionalMojos == null )
{
optionalMojos = Collections.EMPTY_LIST;
}
return optionalMojos;
}
/**
* Find extension.
*
* @param project the project
* @param role the role
* @param roleHint the role hint
* @param settings the settings
* @param localRepository the local repository
* @return the object
* @throws LifecycleExecutionException the lifecycle execution exception
* @throws PluginNotFoundException the plugin not found exception
*/
private Object findExtension( MavenProject project, String role, String roleHint, Settings settings,
ArtifactRepository localRepository )
throws LifecycleExecutionException, PluginNotFoundException
{
Object pluginComponent = null;
for ( Iterator i = project.getBuildPlugins().iterator(); i.hasNext() && pluginComponent == null; )
{
Plugin plugin = (Plugin) i.next();
if ( plugin.isExtensions() )
{
verifyPlugin( plugin, project, settings, localRepository );
// TODO: if moved to the plugin manager we
// already have the descriptor from above
// and so do can lookup the container
// directly
try
{
pluginComponent = pluginManager.getPluginComponent( plugin, role, roleHint );
}
catch ( ComponentLookupException e )
{
log.debug( "Unable to find the lifecycle component in the extension", e );
}
catch ( PluginManagerException e )
{
throw new LifecycleExecutionException( "Error getting extensions from the plugin '"
+ plugin.getKey() + "': " + e.getMessage(), e );
}
}
}
return pluginComponent;
}
/**
* Verify plugin.
*
* @param plugin the plugin
* @param project the project
* @param settings the settings
* @param localRepository the local repository
* @return the plugin descriptor
* @throws LifecycleExecutionException the lifecycle execution exception
* @throws PluginNotFoundException the plugin not found exception
*/
private PluginDescriptor verifyPlugin( Plugin plugin, MavenProject project, Settings settings,
ArtifactRepository localRepository )
throws LifecycleExecutionException, PluginNotFoundException
{
PluginDescriptor pluginDescriptor;
try
{
pluginDescriptor = pluginManager.verifyPlugin( plugin, project, settings, localRepository );
}
catch ( PluginManagerException e )
{
throw new LifecycleExecutionException( "Internal error in the plugin manager getting plugin '"
+ plugin.getKey() + "': " + e.getMessage(), e );
}
catch ( PluginVersionResolutionException e )
{
throw new LifecycleExecutionException( e.getMessage(), e );
}
catch ( InvalidVersionSpecificationException e )
{
throw new LifecycleExecutionException( e.getMessage(), e );
}
catch ( InvalidPluginException e )
{
throw new LifecycleExecutionException( e.getMessage(), e );
}
catch ( ArtifactNotFoundException e )
{
throw new LifecycleExecutionException( e.getMessage(), e );
}
catch ( ArtifactResolutionException e )
{
throw new LifecycleExecutionException( e.getMessage(), e );
}
catch ( PluginVersionNotFoundException e )
{
throw new LifecycleExecutionException( e.getMessage(), e );
}
return pluginDescriptor;
}
/**
* Gets all plugin entries in build.plugins, build.pluginManagement.plugins, profile.build.plugins, reporting and
* profile.reporting in this project and all parents
*
* @param project the project
* @return the all plugin entries wrapped in a PluginWrapper Object
* @throws ArtifactResolutionException the artifact resolution exception
* @throws ArtifactNotFoundException the artifact not found exception
* @throws IOException Signals that an I/O exception has occurred.
* @throws XmlPullParserException the xml pull parser exception
*/
protected List getAllPluginEntries( MavenProject project )
throws ArtifactResolutionException, ArtifactNotFoundException, IOException, XmlPullParserException
{
List plugins = new ArrayList();
// get all the pom models
String pomName = null;
try
{
pomName = project.getFile().getName();
}
catch (Exception e)
{
pomName = "pom.xml";
}
List models =
utils.getModelsRecursively( project.getGroupId(), project.getArtifactId(), project.getVersion(),
new File( project.getBasedir(), pomName ) );
// now find all the plugin entries, either in
// build.plugins or build.pluginManagement.plugins, profiles.plugins and reporting
Iterator iter = models.iterator();
while ( iter.hasNext() )
{
Model model = (Model) iter.next();
try
{
plugins.addAll( PluginWrapper.addAll( model.getBuild().getPlugins(), model.getId() + ".build.plugins" ) );
}
catch ( NullPointerException e )
{
// guess there are no plugins here.
}
try
{
// add the reporting plugins
plugins.addAll( PluginWrapper.addAll( model.getReporting().getPlugins(), model.getId() + ".reporting" ) );
}
catch ( NullPointerException e )
{
// guess there are no plugins here.
}
try
{
plugins.addAll( PluginWrapper.addAll( model.getBuild().getPluginManagement().getPlugins(),
model.getId() + ".build.pluginManagement.plugins" ) );
}
catch ( NullPointerException e )
{
// guess there are no plugins here.
}
// Add plugins in profiles
Iterator it = model.getProfiles().iterator();
while ( it.hasNext() )
{
Profile profile = (Profile) it.next();
try
{
plugins.addAll( PluginWrapper.addAll( profile.getBuild().getPlugins(), model.getId()
+ ".profiles.profile[" + profile.getId() + "].build.plugins" ) );
}
catch ( NullPointerException e )
{
// guess there are no plugins here.
}
try
{
// add the reporting plugins
plugins.addAll( PluginWrapper.addAll( profile.getReporting().getPlugins(), model.getId()
+ "profile[" + profile.getId() + "].reporting.plugins" ) );
}
catch ( NullPointerException e )
{
// guess there are no plugins here.
}
try
{
// add the reporting plugins
plugins.addAll( PluginWrapper.addAll( profile.getBuild().getPluginManagement().getPlugins(),
model.getId() + "profile[" + profile.getId()
+ "].build.pluginManagement.plugins" ) );
}
catch ( NullPointerException e )
{
// guess there are no plugins here.
}
}
}
return plugins;
}
/**
* Checks if is ban latest.
*
* @return the banLatest
*/
protected boolean isBanLatest()
{
return this.banLatest;
}
/**
* Sets the ban latest.
*
* @param theBanLatest the banLatest to set
*/
protected void setBanLatest( boolean theBanLatest )
{
this.banLatest = theBanLatest;
}
/**
* Checks if is ban release.
*
* @return the banRelease
*/
protected boolean isBanRelease()
{
return this.banRelease;
}
/**
* Sets the ban release.
*
* @param theBanRelease the banRelease to set
*/
protected void setBanRelease( boolean theBanRelease )
{
this.banRelease = theBanRelease;
}
/**
* Gets the message.
*
* @return the message
*/
protected String getMessage()
{
return this.message;
}
/**
* Sets the message.
*
* @param theMessage the message to set
*/
protected void setMessage( String theMessage )
{
this.message = theMessage;
}
/**
* Gets the utils.
*
* @return the utils
*/
protected EnforcerRuleUtils getUtils()
{
return this.utils;
}
/**
* Sets the utils.
*
* @param theUtils the utils to set
*/
protected void setUtils( EnforcerRuleUtils theUtils )
{
this.utils = theUtils;
}
/**
* Checks if is ban snapshots.
*
* @return the banSnapshots
*/
public boolean isBanSnapshots()
{
return this.banSnapshots;
}
/**
* Sets the ban snapshots.
*
* @param theBanSnapshots the banSnapshots to set
*/
public void setBanSnapshots( boolean theBanSnapshots )
{
this.banSnapshots = theBanSnapshots;
}
/**
* Checks if is ban timestamps.
*
* @return the banTimestamps
*/
public boolean isBanTimestamps()
{
return this.banTimestamps;
}
/**
* Sets the ban timestamps.
*
* @param theBanTimestamps the banTimestamps to set
*/
public void setBanTimestamps( boolean theBanTimestamps )
{
this.banTimestamps = theBanTimestamps;
}
public List getUnCheckedPlugins()
{
return unCheckedPlugins;
}
public void setUnCheckedPlugins( List unCheckedPlugins )
{
this.unCheckedPlugins = unCheckedPlugins;
}
} RequireProperty.java 0000664 0000000 0000000 00000005605 12057112634 0034365 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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 org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
/**
* This rule checks that certain properties are set.
*
* @author Paul Gier
*/
public class RequireProperty
extends AbstractNonCacheableEnforcerRule
{
/** Specify the required property. */
public String property = null;
/** Match the property value to a given regular expression. Defaults to null (any value is ok). */
public String regex = null;
/** Specify a warning message if the regular expression is not matched. */
public String regexMessage = null;
/**
* Execute the rule.
*
* @param helper the helper
* @throws EnforcerRuleException the enforcer rule exception
*/
public void execute( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
Object propValue = null;
try
{
propValue = helper.evaluate( "${" + property + "}" );
}
catch ( ExpressionEvaluationException eee )
{
throw new EnforcerRuleException( "Unable to evaluate property: " + property, eee );
}
// Check that the property is not null or empty string
if ( propValue == null )
{
if ( message == null )
{
message = "Property \"" + property + "\" is required for this build.";
}
throw new EnforcerRuleException( message );
}
// If there is a regex, check that the property matches it
if ( regex != null && !propValue.toString().matches( regex ) )
{
if ( regexMessage == null )
{
regexMessage =
"Property \"" + property + "\" evaluates to \"" + propValue + "\". " +
"This does not match the regular expression \"" + regex + "\"";
}
throw new EnforcerRuleException( regexMessage );
}
}
}
RequireReleaseDeps.java 0000664 0000000 0000000 00000014763 12057112634 0034742 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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.Iterator;
import java.util.List;
import java.util.Set;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.artifact.filter.StrictPatternExcludesArtifactFilter;
import org.apache.maven.shared.artifact.filter.StrictPatternIncludesArtifactFilter;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
/**
* This rule checks that no snapshots are included.
*
* @author Brian Fox
* @version $Id: RequireReleaseDeps.java 989820 2010-08-26 16:52:46Z pgier $
*/
public class RequireReleaseDeps
extends AbstractBanDependencies
{
/**
* Allows this rule to execute only when this project is a release.
*
* @parameter
*/
public boolean onlyWhenRelease = false;
/**
* Allows this rule to fail when the parent is defined as a snapshot.
*
* @parameter
*/
public boolean failWhenParentIsSnapshot = true;
/**
* Dependencies to ignore when checking for release versions. For example, inter-module dependencies
* can be excluded from the check and therefore allowed to contain snapshot versions.
*/
public List excludes = null;
/**
* Dependencies to include when checking for release versions. If any of the included dependencies
* have snapshot versions, the rule will fail.
*/
public List includes = null;
/**
* Override parent to allow optional ignore of this rule.
*/
public void execute( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
boolean callSuper;
MavenProject project = null;
if ( onlyWhenRelease )
{
// get the project
project = getProject( helper );
// only call super if this project is a release
callSuper = !project.getArtifact().isSnapshot();
}
else
{
callSuper = true;
}
if ( callSuper )
{
super.execute( helper );
if ( failWhenParentIsSnapshot )
{
if ( project == null )
{
project = getProject( helper );
}
Artifact parentArtifact = project.getParentArtifact();
if ( parentArtifact != null && parentArtifact.isSnapshot() )
{
throw new EnforcerRuleException( "Parent Cannot be a snapshot: " + parentArtifact.getId() );
}
}
}
}
/**
* @param helper
* @return
* @throws EnforcerRuleException
*/
private MavenProject getProject( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
try
{
return (MavenProject) helper.evaluate( "${project}" );
}
catch ( ExpressionEvaluationException eee )
{
throw new EnforcerRuleException( "Unable to retrieve the MavenProject: ", eee );
}
}
/**
* Checks the set of dependencies to see if any snapshots are included
*
* @param dependencies the dependencies
* @param log the log
* @return the sets the
* @throws EnforcerRuleException the enforcer rule exception
*/
protected Set checkDependencies( Set dependencies, Log log )
throws EnforcerRuleException
{
Set foundSnapshots = new HashSet();
Set filteredDependencies = this.filterArtifacts( dependencies );
Iterator DependencyIter = filteredDependencies.iterator();
while ( DependencyIter.hasNext() )
{
Artifact artifact = (Artifact) DependencyIter.next();
if ( artifact.isSnapshot() )
{
foundSnapshots.add( artifact );
}
}
return foundSnapshots;
}
/*
* Filter the dependency artifacts according to the includes and excludes
* If includes and excludes are both null, the original set is returned.
*
* @param dependencies the list of dependencies to filter
* @return the resulting set of dependencies
*/
public Set filterArtifacts( Set dependencies )
{
if ( includes == null && excludes == null )
{
return dependencies;
}
AndArtifactFilter filter = new AndArtifactFilter( );
if ( includes != null )
{
filter.add( new StrictPatternIncludesArtifactFilter( includes ) );
}
if ( excludes != null )
{
filter.add( new StrictPatternExcludesArtifactFilter( excludes ) );
}
Set result = new HashSet();
Iterator iter = dependencies.iterator();
while ( iter.hasNext() )
{
Artifact artifact = (Artifact) iter.next();
if ( filter.include( artifact ) )
{
result.add( artifact );
}
}
return result;
}
public boolean isOnlyWhenRelease()
{
return onlyWhenRelease;
}
public void setOnlyWhenRelease( boolean onlyWhenRelease )
{
this.onlyWhenRelease = onlyWhenRelease;
}
public boolean isFailWhenParentIsSnapshot()
{
return failWhenParentIsSnapshot;
}
public void setFailWhenParentIsSnapshot( boolean failWhenParentIsSnapshot )
{
this.failWhenParentIsSnapshot = failWhenParentIsSnapshot;
}
}
RequireReleaseVersion.java 0000664 0000000 0000000 00000006406 12057112634 0035467 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer 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 org.apache.maven.artifact.Artifact;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
/**
* This rule checks that the current project is not a snapshot.
*
* @author Brian Fox
*/
public class RequireReleaseVersion
extends AbstractNonCacheableEnforcerRule
{
/**
* Allows this rule to fail when the parent is defined as a snapshot.
*
* @parameter
*/
public boolean failWhenParentIsSnapshot = true;
/*
* (non-Javadoc)
*
* @see org.apache.maven.enforcer.rule.api.EnforcerRule#execute(org.apache.maven.enforcer.rule.api.EnforcerRuleHelper)
*/
public void execute( EnforcerRuleHelper theHelper )
throws EnforcerRuleException
{
MavenProject project = getProject( theHelper );
if ( project.getArtifact().isSnapshot() )
{
StringBuffer buf = new StringBuffer();
if ( message != null )
{
buf.append( message + "\n" );
}
buf.append( "This project cannot be a snapshot:" + project.getArtifact().getId() );
throw new EnforcerRuleException( buf.toString() );
}
if ( failWhenParentIsSnapshot )
{
Artifact parentArtifact = project.getParentArtifact();
if ( parentArtifact != null && parentArtifact.isSnapshot() )
{
throw new EnforcerRuleException( "Parent Cannot be a snapshot: " + parentArtifact.getId() );
}
}
}
/**
* @param helper
* @return
* @throws EnforcerRuleException
*/
private MavenProject getProject( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
try
{
return (MavenProject) helper.evaluate( "${project}" );
}
catch ( ExpressionEvaluationException eee )
{
throw new EnforcerRuleException( "Unable to retrieve the MavenProject: ", eee );
}
}
public boolean isFailWhenParentIsSnapshot()
{
return failWhenParentIsSnapshot;
}
public void setFailWhenParentIsSnapshot( boolean failWhenParentIsSnapshot )
{
this.failWhenParentIsSnapshot = failWhenParentIsSnapshot;
}
}
maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/utils/ 0000775 0000000 0000000 00000000000 12057112634 0031552 5 ustar 00root root 0000000 0000000 DependencyVersionMap.java 0000664 0000000 0000000 00000007123 12057112634 0036423 0 ustar 00root root 0000000 0000000 maven-enforcer-1.0.1/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/utils package org.apache.maven.plugins.enforcer.utils;
/*
* 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.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.shared.dependency.tree.DependencyNode;
import org.apache.maven.shared.dependency.tree.traversal.DependencyNodeVisitor;
public class DependencyVersionMap implements DependencyNodeVisitor {
private boolean demandReleasedVersions = false;
private MapThe prerequisites tag was designed to be used by tools like plugins. It will work for regular projects, but it isn't inherited to their children. If it is set in a parent reactor, then Maven will do the check. However if one of the children are built, the check is not performed. The enforcer plugin is designed to allow centralized control over the build environment from a single "super-pom", and to allow greater flexibility in version specification by supporting ranges.