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 );
}
}
}
././@LongLink 0000000 0000000 0000000 00000000157 00000000000 011570 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/AbstractBanDependencies.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/AbstractBanDepende0000644 0001750 0001750 00000011406 11304270453 033605 0 ustar twerner twerner 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 java.util.Set;
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.plugin.logging.Log;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
/**
* Abstract Rule for banning dependencies.
*
* @author Brian Fox
* @version $Id: AbstractBanDependencies.java 885125 2009-11-28 18:51:23Z brianf $
*/
public abstract class AbstractBanDependencies
extends AbstractNonCacheableEnforcerRule
{
/** Specify if transitive dependencies should be searched (default) or only look at direct dependencies. */
private boolean searchTransitive = true;
/**
* Execute the rule.
*
* @param helper the helper
* @throws EnforcerRuleException the enforcer rule exception
*/
public void execute( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
// get the project
MavenProject project = null;
try
{
project = (MavenProject) helper.evaluate( "${project}" );
}
catch ( ExpressionEvaluationException eee )
{
throw new EnforcerRuleException( "Unable to retrieve the MavenProject: ", eee );
}
// get the correct list of dependencies
Set dependencies = getDependenciesToCheck( project );
// look for banned dependencies
Set foundExcludes = checkDependencies( dependencies, helper.getLog() );
// if any are found, fail the check but list all of them
if ( foundExcludes != null && !foundExcludes.isEmpty() )
{
StringBuffer buf = new StringBuffer();
if ( message != null )
{
buf.append( message + "\n" );
}
Iterator iter = foundExcludes.iterator();
while ( iter.hasNext() )
{
Artifact artifact = (Artifact) iter.next();
buf.append( getErrorMessage( artifact ) );
}
message = buf.toString()+ "Use 'mvn dependency:tree' to locate the source of the banned dependencies.";
throw new EnforcerRuleException( message );
}
}
protected CharSequence getErrorMessage( Artifact artifact )
{
return "Found Banned Dependency: " + artifact.getId() + "\n";
}
protected Set getDependenciesToCheck( MavenProject project )
{
Set dependencies = null;
if ( searchTransitive )
{
dependencies = project.getArtifacts();
}
else
{
dependencies = project.getDependencyArtifacts();
}
return dependencies;
}
/**
* Checks the set of dependencies against the list of excludes.
*
* @param dependencies the dependencies
* @param log the log
* @return the sets the
* @throws EnforcerRuleException the enforcer rule exception
*/
abstract protected Set checkDependencies( Set dependencies, Log log )
throws EnforcerRuleException;
/**
* Gets the message.
*
* @return the message
*/
public String getMessage()
{
return this.message;
}
/**
* Sets the message.
*
* @param theMessage the message to set
*/
public void setMessage( String theMessage )
{
this.message = theMessage;
}
/**
* Checks if is search transitive.
*
* @return the searchTransitive
*/
public boolean isSearchTransitive()
{
return this.searchTransitive;
}
/**
* Sets the search transitive.
*
* @param theSearchTransitive the searchTransitive to set
*/
public void setSearchTransitive( boolean theSearchTransitive )
{
this.searchTransitive = theSearchTransitive;
}
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequireFilesExist.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequireFilesExist.0000644 0001750 0001750 00000002736 11124337702 033635 0 ustar twerner twerner 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";
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequireFilesSize.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequireFilesSize.j0000644 0001750 0001750 00000010713 11242355031 033613 0 ustar twerner twerner 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;
}
}
maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/AlwaysFail.java 0000644 0001750 0001750 00000003104 11433603551 033106 0 ustar twerner twerner 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;
/**
* Always fail. This rule is useful for testing the Enforcer configuration, or to always fail the build if a particular
* profile is enabled.
* @author Ben Lidgey
*/
public class AlwaysFail
extends AbstractNonCacheableEnforcerRule
{
/**
* {@inheritDoc}
*/
public void execute( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
StringBuffer buf = new StringBuffer();
if ( message != null )
{
buf.append( message + "\n" );
}
buf.append( "Always fails!" );
throw new EnforcerRuleException( buf.toString() );
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/BannedPlugins.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/BannedPlugins.java0000644 0001750 0001750 00000002704 11433776614 033623 0 ustar twerner twerner 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";
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequirePluginVersions.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequirePluginVersi0000644 0001750 0001750 00000120571 11462137622 033751 0 ustar twerner twerner 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.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import org.apache.maven.BuildFailureException;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.lifecycle.Lifecycle;
import org.apache.maven.lifecycle.LifecycleExecutionException;
import org.apache.maven.lifecycle.LifecycleExecutor;
import org.apache.maven.lifecycle.mapping.LifecycleMapping;
import org.apache.maven.model.BuildBase;
import org.apache.maven.model.Model;
import org.apache.maven.model.Plugin;
import org.apache.maven.model.Profile;
import org.apache.maven.plugin.InvalidPluginException;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.PluginManager;
import org.apache.maven.plugin.PluginManagerException;
import org.apache.maven.plugin.PluginNotFoundException;
import org.apache.maven.plugin.descriptor.PluginDescriptor;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.plugin.version.PluginVersionNotFoundException;
import org.apache.maven.plugin.version.PluginVersionResolutionException;
import org.apache.maven.plugins.enforcer.utils.EnforcerRuleUtils;
import org.apache.maven.plugins.enforcer.utils.PluginWrapper;
import org.apache.maven.project.MavenProject;
import org.apache.maven.settings.Settings;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
import org.codehaus.plexus.util.ReflectionUtils;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
/**
* This rule will enforce that all plugins specified in the poms have a version declared.
*
* @author Brian Fox
* @version $Id: RequirePluginVersions.java 1028144 2010-10-28 00:10:58Z brianf $
*/
public class RequirePluginVersions
extends AbstractNonCacheableEnforcerRule
{
/** Don't allow the LATEST identifier. */
public boolean banLatest = true;
/** Don't allow the RELEASE identifier. */
public boolean banRelease = true;
/** Don't allow snapshot plugins. */
public boolean banSnapshots = true;
/** Don't allow timestamp snapshot plugins. */
public boolean banTimestamps = true;
/**
* The comma separated list of phases that should be used to find lifecycle plugin bindings. The default value is
* "clean,deploy,site".
*/
public String phases = "clean,deploy,site";
/**
* Additional plugins to enforce have versions. These are plugins that may not be in the poms but are used anyway,
* like help, eclipse etc. group: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;
}
} ././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/AbstractRequireFiles.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/AbstractRequireFil0000644 0001750 0001750 00000013411 11242355031 033662 0 ustar twerner twerner 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.ArrayList;
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;
/**
* Contains the common code to compare an array of files against a requirement.
*
* @author Brian Fox
*/
public abstract class AbstractRequireFiles
extends AbstractStandardEnforcerRule
{
/** Array of files to check. */
File[] files;
/** if null file handles should be allowed. If they are allowed, it means treat it as a success. */
boolean allowNulls = false;
// check the file for the specific condition
/**
* Check one file.
*
* @param file the file
* @return 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;
}
}
././@LongLink 0000000 0000000 0000000 00000000164 00000000000 011566 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/AbstractStandardEnforcerRule.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/AbstractStandardEn0000644 0001750 0001750 00000002160 11242355031 033635 0 ustar twerner twerner 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;
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/DependencyConvergence.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/DependencyConverge0000644 0001750 0001750 00000020411 11464077650 033712 0 ustar twerner twerner 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;
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequireNoRepositories.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequireNoRepositor0000644 0001750 0001750 00000016355 11301757703 033771 0 ustar twerner twerner 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/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/utils/ 0000755 0001750 0001750 00000000000 11633465166 031363 5 ustar twerner twerner ././@LongLink 0000000 0000000 0000000 00000000157 00000000000 011570 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/utils/EnforcerRuleUtils.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/utils/EnforcerRule0000644 0001750 0001750 00000025131 11242355031 033664 0 ustar twerner twerner 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.io.File;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.model.Model;
import org.apache.maven.model.Parent;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
// TODO: Auto-generated Javadoc
/**
* The Class EnforcerRuleUtils.
*
* @author Brian Fox
*/
public class EnforcerRuleUtils
{
/** The factory. */
ArtifactFactory factory;
/** The resolver. */
ArtifactResolver resolver;
/** The local. */
ArtifactRepository local;
/** The remote repositories. */
List remoteRepositories;
/** The log. */
Log log;
/** The project. */
MavenProject project;
private EnforcerRuleHelper helper;
/**
* Instantiates a new enforcer rule utils.
*
* @param theFactory the the factory
* @param theResolver the the resolver
* @param theLocal the the local
* @param theRemoteRepositories the the remote repositories
* @param project the project
* @param theLog the the log
*/
public EnforcerRuleUtils( ArtifactFactory theFactory, ArtifactResolver theResolver, ArtifactRepository theLocal,
List theRemoteRepositories, MavenProject project, Log theLog )
{
super();
this.factory = theFactory;
this.resolver = theResolver;
this.local = theLocal;
this.remoteRepositories = theRemoteRepositories;
this.log = theLog;
this.project = project;
}
/**
* Instantiates a new enforcer rule utils.
*
* @param helper the helper
*/
public EnforcerRuleUtils( EnforcerRuleHelper helper )
{
this.helper = helper;
// get the various expressions out of the
// helper.
try
{
factory = (ArtifactFactory) helper.getComponent( ArtifactFactory.class );
resolver = (ArtifactResolver) helper.getComponent( ArtifactResolver.class );
local = (ArtifactRepository) helper.evaluate( "${localRepository}" );
project = (MavenProject) helper.evaluate( "${project}" );
remoteRepositories = project.getRemoteArtifactRepositories();
}
catch ( ComponentLookupException e )
{
// TODO Auto-generated catch block
e.printStackTrace();
}
catch ( ExpressionEvaluationException e )
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* Gets the pom model for this file.
*
* @param pom the pom
*
* @return the model
*
* @throws IOException Signals that an I/O exception has occurred.
* @throws XmlPullParserException the xml pull parser exception
*/
private Model readModel ( File pom )
throws IOException, XmlPullParserException
{
Reader reader = ReaderFactory.newXmlReader( pom );
MavenXpp3Reader xpp3 = new MavenXpp3Reader();
Model model = null;
try
{
model = xpp3.read( reader );
}
finally
{
reader.close();
reader = null;
}
return model;
}
/**
* This method gets the model for the defined artifact.
* Looks first in the filesystem, then tries to get it
* from the repo.
*
* @param groupId the group id
* @param artifactId the artifact id
* @param version the version
* @param pom the pom
*
* @return the pom model
*
* @throws ArtifactResolutionException the artifact resolution exception
* @throws ArtifactNotFoundException the artifact not found exception
* @throws XmlPullParserException the xml pull parser exception
* @throws IOException Signals that an I/O exception has occurred.
*/
private Model getPomModel ( String groupId, String artifactId, String version, File pom )
throws ArtifactResolutionException, ArtifactNotFoundException, IOException, XmlPullParserException
{
Model model = null;
// do we want to look in the reactor like the
// project builder? Would require @aggregator goal
// which causes problems in maven core right now
// because we also need dependency resolution in
// other
// rules. (MNG-2277)
// look in the location specified by pom first.
boolean found = false;
try
{
model = readModel( pom );
// i found a model, lets make sure it's the one
// I want
found = checkIfModelMatches( groupId, artifactId, version, model );
}
catch ( IOException e )
{
// nothing here, but lets look in the repo
// before giving up.
}
catch ( XmlPullParserException e )
{
// nothing here, but lets look in the repo
// before giving up.
}
// i didn't find it in the local file system, go
// look in the repo
if ( !found )
{
Artifact pomArtifact = factory.createArtifact( groupId, artifactId, version, null, "pom" );
resolver.resolve( pomArtifact, remoteRepositories, local );
model = readModel( pomArtifact.getFile() );
}
return model;
}
/**
* This method loops through all the parents, getting
* each pom model and then its parent.
*
* @param groupId the group id
* @param artifactId the artifact id
* @param version the version
* @param pom the pom
*
* @return the models recursively
*
* @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
*/
public List getModelsRecursively ( String groupId, String artifactId, String version, File pom )
throws ArtifactResolutionException, ArtifactNotFoundException, IOException, XmlPullParserException
{
List models = null;
Model model = getPomModel( groupId, artifactId, version, pom );
Parent parent = model.getParent();
// recurse into the parent
if ( parent != null )
{
// get the relative path
String relativePath = parent.getRelativePath();
if ( StringUtils.isEmpty( relativePath ) )
{
relativePath = "../pom.xml";
}
// calculate the recursive path
File parentPom = new File( pom.getParent(), relativePath );
// if relative path is a directory, append pom.xml
if ( parentPom.isDirectory() )
{
parentPom = new File( parentPom, "pom.xml" );
}
models = getModelsRecursively( parent.getGroupId(), parent.getArtifactId(), parent.getVersion(), parentPom );
}
else
{
// only create it here since I'm not at the top
models = new ArrayList();
}
models.add( model );
return models;
}
/**
* Make sure the model is the one I'm expecting.
*
* @param groupId the group id
* @param artifactId the artifact id
* @param version the version
* @param model Model being checked.
*
* @return true, if check if model matches
*/
protected boolean checkIfModelMatches ( String groupId, String artifactId, String version, Model model )
{
// try these first.
String modelGroup = model.getGroupId();
String modelVersion = model.getVersion();
try
{
if ( StringUtils.isEmpty( modelGroup ) )
{
modelGroup = model.getParent().getGroupId();
}
else
{
//MENFORCER-30, handle cases where the value is a property like ${project.parent.groupId}
modelGroup = (String) helper.evaluate( modelGroup );
}
if ( StringUtils.isEmpty( modelVersion ) )
{
modelVersion = model.getParent().getVersion();
}
else
{
//MENFORCER-30, handle cases where the value is a property like ${project.parent.version}
modelVersion = (String) helper.evaluate( modelVersion );
}
}
catch ( NullPointerException e )
{
// this is probably bad. I don't have a valid
// group or version and I can't find a
// parent????
// lets see if it's what we're looking for
// anyway.
}
catch ( ExpressionEvaluationException e )
{
// as above
}
return ( StringUtils.equals( groupId, modelGroup ) && StringUtils.equals( version, modelVersion ) && StringUtils
.equals( artifactId, model.getArtifactId() ) );
}
}
././@LongLink 0000000 0000000 0000000 00000000162 00000000000 011564 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/utils/DependencyVersionMap.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/utils/DependencyVe0000644 0001750 0001750 00000007123 11462151050 033642 0 ustar twerner twerner 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 MapgroupId[: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;
}
}
././@LongLink 0000000 0000000 0000000 00000000152 00000000000 011563 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequireReleaseDeps.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequireReleaseDeps0000644 0001750 0001750 00000014763 11435515736 033711 0 ustar twerner twerner 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;
}
}
maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/NoSnapshots.java 0000644 0001750 0001750 00000003552 11433776614 033353 0 ustar twerner twerner 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.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.plugin.logging.Log;
/**
* This rule is deprecated. Use requireReleaseVersions.
*
* @author Brian Fox
* @version $Id: NoSnapshots.java 987781 2010-08-21 16:23:40Z dennisl $
* @deprecated replaced by {@link RequireReleaseDeps}
*/
public class NoSnapshots
extends AbstractBanDependencies
{
/**
* 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
{
log.warn( "The \"NoSnapshots\" rule is deprecated. Use \"requireReleaseDeps\" instead" );
RequireReleaseDeps rule = new RequireReleaseDeps();
return rule.checkDependencies( dependencies, log );
}
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/EvaluateBeanshell.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/EvaluateBeanshell.0000644 0001750 0001750 00000006531 11242355031 033576 0 ustar twerner twerner 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.apache.maven.plugin.logging.Log;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
import org.codehaus.plexus.util.StringUtils;
import bsh.EvalError;
import bsh.Interpreter;
/**
* Rule for Maven Enforcer using Beanshell to evaluate a conditional expression.
*
* @author hugonnem
*/
public class EvaluateBeanshell
extends AbstractNonCacheableEnforcerRule
{
/** Beanshell interpreter. */
private static final Interpreter bsh = new Interpreter();
/** The condition to be evaluated. */
public String condition;
/*
* (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 log = helper.getLog();
try
{
log.debug( "Echo condition : " + this.condition );
// Evaluate condition within Plexus Container
String script = (String) helper.evaluate( this.condition );
log.debug( "Echo script : " + script );
if ( !evaluateCondition( script, log ) )
{
if ( StringUtils.isEmpty( message ) )
{
message = "The expression \"" + condition + "\" is not true.";
}
throw new EnforcerRuleException( this.message );
}
}
catch ( ExpressionEvaluationException e )
{
throw new EnforcerRuleException( "Unable to evaluate an expression '" + condition + "'", e );
}
}
/**
* Evaluate expression using Beanshell.
*
* @param script the expression to be evaluated
* @param log the logger
* @return boolean the evaluation of the expression
* @throws EnforcerRuleException if the script could not be evaluated
*/
protected boolean evaluateCondition( String script, Log log )
throws EnforcerRuleException
{
Boolean evaluation = Boolean.FALSE;
try
{
evaluation = (Boolean) bsh.eval( script );
log.debug( "Echo evaluating : " + evaluation );
}
catch ( EvalError ex )
{
throw new EnforcerRuleException( "Couldn't evaluate condition: " + script, ex );
}
return evaluation.booleanValue();
}
}
././@LongLink 0000000 0000000 0000000 00000000152 00000000000 011563 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequireJavaVersion.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/RequireJavaVersion0000644 0001750 0001750 00000007526 11242355031 033725 0 ustar twerner twerner 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, "." );
}
}
././@LongLink 0000000 0000000 0000000 00000000157 00000000000 011570 L ustar root root maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/AbstractVersionEnforcer.java maven-enforcer-1.0/enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/AbstractVersionEnf0000644 0001750 0001750 00000016165 11242355031 033702 0 ustar twerner twerner 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 higherThe 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.
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();
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root maven-enforcer-1.0/enforcer-api/src/main/java/org/apache/maven/enforcer/rule/api/EnforcerRuleHelper.java maven-enforcer-1.0/enforcer-api/src/main/java/org/apache/maven/enforcer/rule/api/EnforcerRuleHelper.0000644 0001750 0001750 00000006370 11242350104 033420 0 ustar twerner twerner 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();
}
././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root maven-enforcer-1.0/enforcer-api/src/main/java/org/apache/maven/enforcer/rule/api/EnforcerRuleException.java maven-enforcer-1.0/enforcer-api/src/main/java/org/apache/maven/enforcer/rule/api/EnforcerRuleExcepti0000644 0001750 0001750 00000006165 11242350104 033526 0 ustar twerner twerner 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 );
}
}