| package org.apache.maven.archiva.repository.project.filters; |
| |
| /* |
| * 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.commons.collections.CollectionUtils; |
| import org.apache.commons.lang.StringUtils; |
| import org.apache.maven.archiva.model.ArchivaModelCloner; |
| import org.apache.maven.archiva.model.ArchivaProjectModel; |
| import org.apache.maven.archiva.model.ArtifactReference; |
| import org.apache.maven.archiva.model.CiManagement; |
| import org.apache.maven.archiva.model.Dependency; |
| import org.apache.maven.archiva.model.Exclusion; |
| import org.apache.maven.archiva.model.Individual; |
| import org.apache.maven.archiva.model.IssueManagement; |
| import org.apache.maven.archiva.model.License; |
| import org.apache.maven.archiva.model.MailingList; |
| import org.apache.maven.archiva.model.Organization; |
| import org.apache.maven.archiva.model.ProjectRepository; |
| import org.apache.maven.archiva.model.Scm; |
| import org.apache.maven.archiva.model.VersionedReference; |
| import org.apache.maven.archiva.repository.project.ProjectModelException; |
| import org.apache.maven.archiva.repository.project.ProjectModelFilter; |
| import org.codehaus.plexus.evaluator.DefaultExpressionEvaluator; |
| import org.codehaus.plexus.evaluator.EvaluatorException; |
| import org.codehaus.plexus.evaluator.ExpressionEvaluator; |
| import org.codehaus.plexus.evaluator.ExpressionSource; |
| import org.codehaus.plexus.evaluator.sources.PropertiesExpressionSource; |
| import org.codehaus.plexus.evaluator.sources.SystemPropertyExpressionSource; |
| |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Properties; |
| import java.util.Set; |
| |
| /** |
| * ProjectModelExpressionFilter |
| * |
| * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a> |
| * @version $Id$ |
| * @plexus.component role="org.apache.maven.archiva.repository.project.ProjectModelFilter" |
| * role-hint="expression" |
| * instantiation-strategy="per-lookup" |
| */ |
| public class ProjectModelExpressionFilter |
| implements ProjectModelFilter |
| { |
| private ExpressionEvaluator evaluator = new DefaultExpressionEvaluator(); |
| |
| /** |
| * Find and Evaluate the Expressions present in the model. |
| * |
| * @param model the model to correct. |
| */ |
| public ArchivaProjectModel filter( final ArchivaProjectModel model ) |
| throws ProjectModelException |
| { |
| Properties props = new Properties(); |
| |
| if ( model.getProperties() != null ) |
| { |
| props.putAll( model.getProperties() ); |
| } |
| |
| ArchivaProjectModel ret = ArchivaModelCloner.clone( model ); |
| |
| // TODO: should probably clone evaluator to prevent threading issues. |
| synchronized ( evaluator ) |
| { |
| // TODO: create .resetSources() method in ExpressionEvaluator project on plexus side. |
| // Remove previous expression sources. |
| List<ExpressionSource> oldSources = new ArrayList<ExpressionSource>(); |
| oldSources.addAll( evaluator.getExpressionSourceList() ); |
| for ( ExpressionSource exprSrc : oldSources ) |
| { |
| evaluator.removeExpressionSource( exprSrc ); |
| } |
| |
| // Setup new sources (based on current model) |
| PropertiesExpressionSource propsSource = new PropertiesExpressionSource(); |
| propsSource.setProperties( props ); |
| evaluator.addExpressionSource( propsSource ); |
| |
| // Add system properties to the mix. |
| evaluator.addExpressionSource( new SystemPropertyExpressionSource() ); |
| |
| try |
| { |
| // Setup some common properties. |
| VersionedReference parent = model.getParentProject(); |
| if ( parent != null ) |
| { |
| String parentGroupId = StringUtils.defaultString( evaluator.expand( parent.getGroupId() ) ); |
| String parentArtifactId = StringUtils.defaultString( evaluator.expand( parent.getArtifactId() ) ); |
| String parentVersion = StringUtils.defaultString( evaluator.expand( parent.getVersion() ) ); |
| |
| props.setProperty( "parent.groupId", parentGroupId ); |
| props.setProperty( "parent.artifactId", parentArtifactId ); |
| props.setProperty( "parent.version", parentVersion ); |
| } |
| |
| String groupId = StringUtils.defaultString( evaluator.expand( model.getGroupId() ) ); |
| String artifactId = StringUtils.defaultString( evaluator.expand( model.getArtifactId() ) ); |
| String version = StringUtils.defaultString( evaluator.expand( model.getVersion() ) ); |
| String name = StringUtils.defaultString( evaluator.expand( model.getName() ) ); |
| |
| |
| /* Archiva doesn't need to handle a full expression language with object tree walking |
| * as the requirements within Archiva are much smaller, a quick replacement of the |
| * important fields (groupId, artifactId, version, name) are handled specifically. |
| */ |
| props.setProperty( "pom.groupId", groupId ); |
| props.setProperty( "pom.artifactId", artifactId ); |
| props.setProperty( "pom.version", version ); |
| props.setProperty( "pom.name", name ); |
| props.setProperty( "project.groupId", groupId ); |
| props.setProperty( "project.artifactId", artifactId ); |
| props.setProperty( "project.version", version ); |
| props.setProperty( "project.name", name ); |
| |
| // Evaluate everything. |
| ret.setVersion( evaluator.expand( ret.getVersion() ) ); |
| ret.setGroupId( evaluator.expand( ret.getGroupId() ) ); |
| ret.setName( evaluator.expand( ret.getName() ) ); |
| ret.setDescription( evaluator.expand( ret.getDescription() ) ); |
| ret.setPackaging( evaluator.expand( ret.getPackaging() ) ); |
| ret.setUrl( evaluator.expand( ret.getUrl() ) ); |
| |
| evaluateParentProject( evaluator, ret.getParentProject() ); |
| |
| evaluateBuildExtensions( evaluator, ret.getBuildExtensions() ); |
| evaluateCiManagement( evaluator, ret.getCiManagement() ); |
| evaluateDependencyList( evaluator, ret.getDependencies() ); |
| evaluateDependencyList( evaluator, ret.getDependencyManagement() ); |
| evaluateIndividuals( evaluator, ret.getIndividuals() ); |
| evaluateIssueManagement( evaluator, ret.getIssueManagement() ); |
| evaluateLicenses( evaluator, ret.getLicenses() ); |
| evaluateMailingLists( evaluator, ret.getMailingLists() ); |
| evaluateOrganization( evaluator, ret.getOrganization() ); |
| evaluatePlugins( evaluator, ret.getPlugins() ); |
| evaluateRelocation( evaluator, ret.getRelocation() ); |
| evaluateReports( evaluator, ret.getReports() ); |
| evaluateRepositories( evaluator, ret.getRepositories() ); |
| evaluateScm( evaluator, ret.getScm() ); |
| } |
| catch ( EvaluatorException e ) |
| { |
| throw new ProjectModelException( "Unable to evaluate expression in model: " + e.getMessage(), e ); |
| } |
| } |
| |
| return ret; |
| } |
| |
| private void evaluateArtifactReferenceList( ExpressionEvaluator eval, List<ArtifactReference> refs ) |
| throws EvaluatorException |
| { |
| if ( CollectionUtils.isEmpty( refs ) ) |
| { |
| return; |
| } |
| |
| for ( ArtifactReference ref : refs ) |
| { |
| ref.setGroupId( eval.expand( ref.getGroupId() ) ); |
| ref.setArtifactId( eval.expand( ref.getArtifactId() ) ); |
| ref.setVersion( eval.expand( ref.getVersion() ) ); |
| ref.setClassifier( eval.expand( ref.getClassifier() ) ); |
| ref.setType( eval.expand( ref.getType() ) ); |
| } |
| } |
| |
| private void evaluateBuildExtensions( ExpressionEvaluator eval, List<ArtifactReference> buildExtensions ) |
| throws EvaluatorException |
| { |
| if ( CollectionUtils.isEmpty( buildExtensions ) ) |
| { |
| return; |
| } |
| |
| for ( ArtifactReference ref : buildExtensions ) |
| { |
| ref.setGroupId( eval.expand( ref.getGroupId() ) ); |
| ref.setArtifactId( eval.expand( ref.getArtifactId() ) ); |
| ref.setVersion( eval.expand( ref.getVersion() ) ); |
| ref.setClassifier( eval.expand( ref.getClassifier() ) ); |
| ref.setType( eval.expand( ref.getType() ) ); |
| } |
| } |
| |
| private void evaluateCiManagement( ExpressionEvaluator eval, CiManagement ciManagement ) |
| throws EvaluatorException |
| { |
| if ( ciManagement == null ) |
| { |
| return; |
| } |
| |
| ciManagement.setSystem( eval.expand( ciManagement.getSystem() ) ); |
| ciManagement.setUrl( eval.expand( ciManagement.getUrl() ) ); |
| } |
| |
| private void evaluateDependencyList( ExpressionEvaluator eval, List<Dependency> dependencies ) |
| throws EvaluatorException |
| { |
| if ( CollectionUtils.isEmpty( dependencies ) ) |
| { |
| return; |
| } |
| |
| for ( Dependency dependency : dependencies ) |
| { |
| dependency.setGroupId( eval.expand( dependency.getGroupId() ) ); |
| dependency.setArtifactId( eval.expand( dependency.getArtifactId() ) ); |
| dependency.setVersion( eval.expand( dependency.getVersion() ) ); |
| dependency.setScope( eval.expand( dependency.getScope() ) ); |
| dependency.setType( eval.expand( dependency.getType() ) ); |
| dependency.setUrl( eval.expand( dependency.getUrl() ) ); |
| |
| evaluateExclusions( eval, dependency.getExclusions() ); |
| } |
| } |
| |
| private void evaluateExclusions( ExpressionEvaluator eval, List<Exclusion> exclusions ) |
| throws EvaluatorException |
| { |
| if ( CollectionUtils.isEmpty( exclusions ) ) |
| { |
| return; |
| } |
| |
| for ( Exclusion exclusion : exclusions ) |
| { |
| exclusion.setGroupId( eval.expand( exclusion.getGroupId() ) ); |
| exclusion.setArtifactId( eval.expand( exclusion.getArtifactId() ) ); |
| } |
| } |
| |
| private void evaluateIndividuals( ExpressionEvaluator eval, List<Individual> individuals ) |
| throws EvaluatorException |
| { |
| if ( CollectionUtils.isEmpty( individuals ) ) |
| { |
| return; |
| } |
| |
| for ( Individual individual : individuals ) |
| { |
| individual.setPrincipal( eval.expand( individual.getPrincipal() ) ); |
| individual.setName( eval.expand( individual.getName() ) ); |
| individual.setEmail( eval.expand( individual.getEmail() ) ); |
| individual.setTimezone( eval.expand( individual.getTimezone() ) ); |
| individual.setOrganization( eval.expand( individual.getOrganization() ) ); |
| individual.setOrganizationUrl( eval.expand( individual.getOrganizationUrl() ) ); |
| individual.setUrl( eval.expand( individual.getUrl() ) ); |
| |
| evaluateProperties( eval, individual.getProperties() ); |
| evaluateStringList( eval, individual.getRoles() ); |
| } |
| } |
| |
| private void evaluateIssueManagement( ExpressionEvaluator eval, IssueManagement issueManagement ) |
| throws EvaluatorException |
| { |
| if ( issueManagement == null ) |
| { |
| return; |
| } |
| |
| issueManagement.setSystem( eval.expand( issueManagement.getSystem() ) ); |
| issueManagement.setUrl( eval.expand( issueManagement.getUrl() ) ); |
| } |
| |
| private void evaluateLicenses( ExpressionEvaluator eval, List<License> licenses ) |
| throws EvaluatorException |
| { |
| if ( CollectionUtils.isEmpty( licenses ) ) |
| { |
| return; |
| } |
| |
| for ( License license : licenses ) |
| { |
| license.setName( eval.expand( license.getName() ) ); |
| license.setUrl( eval.expand( license.getUrl() ) ); |
| license.setComments( eval.expand( license.getComments() ) ); |
| } |
| } |
| |
| private void evaluateMailingLists( ExpressionEvaluator eval, List<MailingList> mailingLists ) |
| throws EvaluatorException |
| { |
| if ( CollectionUtils.isEmpty( mailingLists ) ) |
| { |
| return; |
| } |
| |
| for ( MailingList mlist : mailingLists ) |
| { |
| mlist.setName( eval.expand( mlist.getName() ) ); |
| mlist.setSubscribeAddress( eval.expand( mlist.getSubscribeAddress() ) ); |
| mlist.setUnsubscribeAddress( eval.expand( mlist.getUnsubscribeAddress() ) ); |
| mlist.setPostAddress( eval.expand( mlist.getPostAddress() ) ); |
| mlist.setMainArchiveUrl( eval.expand( mlist.getMainArchiveUrl() ) ); |
| |
| evaluateStringList( eval, mlist.getOtherArchives() ); |
| } |
| } |
| |
| private void evaluateOrganization( ExpressionEvaluator eval, Organization organization ) |
| throws EvaluatorException |
| { |
| if ( organization == null ) |
| { |
| return; |
| } |
| |
| organization.setName( eval.expand( organization.getName() ) ); |
| organization.setUrl( eval.expand( organization.getUrl() ) ); |
| organization.setFavicon( eval.expand( organization.getFavicon() ) ); |
| } |
| |
| private void evaluateParentProject( ExpressionEvaluator eval, VersionedReference parentProject ) |
| throws EvaluatorException |
| { |
| if ( parentProject == null ) |
| { |
| return; |
| } |
| |
| parentProject.setGroupId( eval.expand( parentProject.getGroupId() ) ); |
| parentProject.setArtifactId( eval.expand( parentProject.getArtifactId() ) ); |
| parentProject.setVersion( eval.expand( parentProject.getVersion() ) ); |
| } |
| |
| private void evaluatePlugins( ExpressionEvaluator eval, List<ArtifactReference> plugins ) |
| throws EvaluatorException |
| { |
| evaluateArtifactReferenceList( eval, plugins ); |
| } |
| |
| private void evaluateProperties( ExpressionEvaluator eval, Properties props ) |
| throws EvaluatorException |
| { |
| if ( props == null ) |
| { |
| return; |
| } |
| |
| // Only evaluate the values, not the keys. |
| |
| // Collect the key names. (Done ahead of time to prevent iteration / concurrent modification exceptions) |
| Set<String> keys = new HashSet<String>(); |
| for ( Object obj : props.keySet() ) |
| { |
| keys.add( (String) obj ); |
| } |
| |
| // Evaluate all of the values. |
| for ( String key : keys ) |
| { |
| String value = props.getProperty( key ); |
| props.setProperty( key, eval.expand( value ) ); |
| } |
| } |
| |
| private void evaluateRelocation( ExpressionEvaluator eval, VersionedReference relocation ) |
| throws EvaluatorException |
| { |
| if ( relocation == null ) |
| { |
| return; |
| } |
| |
| relocation.setGroupId( eval.expand( relocation.getGroupId() ) ); |
| relocation.setArtifactId( eval.expand( relocation.getArtifactId() ) ); |
| relocation.setVersion( eval.expand( relocation.getVersion() ) ); |
| } |
| |
| private void evaluateReports( ExpressionEvaluator eval, List<ArtifactReference> reports ) |
| throws EvaluatorException |
| { |
| evaluateArtifactReferenceList( eval, reports ); |
| } |
| |
| private void evaluateRepositories( ExpressionEvaluator eval, List<ProjectRepository> repositories ) |
| throws EvaluatorException |
| { |
| if ( CollectionUtils.isEmpty( repositories ) ) |
| { |
| return; |
| } |
| |
| for ( ProjectRepository repository : repositories ) |
| { |
| repository.setId( eval.expand( repository.getId() ) ); |
| repository.setLayout( eval.expand( repository.getLayout() ) ); |
| repository.setName( eval.expand( repository.getName() ) ); |
| repository.setUrl( eval.expand( repository.getUrl() ) ); |
| } |
| } |
| |
| private void evaluateScm( ExpressionEvaluator eval, Scm scm ) |
| throws EvaluatorException |
| { |
| if ( scm == null ) |
| { |
| return; |
| } |
| |
| scm.setConnection( eval.expand( scm.getConnection() ) ); |
| scm.setDeveloperConnection( eval.expand( scm.getDeveloperConnection() ) ); |
| scm.setUrl( eval.expand( scm.getUrl() ) ); |
| } |
| |
| private void evaluateStringList( ExpressionEvaluator eval, List<String> strings ) |
| throws EvaluatorException |
| { |
| if ( CollectionUtils.isEmpty( strings ) ) |
| { |
| return; |
| } |
| |
| // Create new list to hold post-evaluated strings. |
| List<String> evaluated = new ArrayList<String>(); |
| |
| // Evaluate them all |
| for ( String str : strings ) |
| { |
| evaluated.add( eval.expand( str ) ); |
| } |
| |
| // Populate the original list with the post-evaluated list. |
| strings.clear(); |
| strings.addAll( evaluated ); |
| } |
| } |
