tools/maven-bundle-plugin/src/main/java/org/apache/felix/bundleplugin/AbstractDependencyFilter.java - onos-felix - Gitiles

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.felix.bundleplugin;


 import java.util.Collection;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.regex.Pattern;

 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
 import org.apache.maven.plugin.MojoExecutionException;

 import aQute.bnd.header.Attrs;
 import aQute.bnd.header.OSGiHeader;
 import aQute.bnd.osgi.Instruction;
 import org.apache.maven.shared.dependency.graph.DependencyNode;
 import org.apache.maven.shared.dependency.graph.filter.ArtifactDependencyNodeFilter;
 import org.apache.maven.shared.dependency.graph.filter.DependencyNodeFilter;
 import org.apache.maven.shared.dependency.graph.traversal.BuildingDependencyNodeVisitor;
 import org.apache.maven.shared.dependency.graph.traversal.CollectingDependencyNodeVisitor;
 import org.apache.maven.shared.dependency.graph.traversal.DependencyNodeVisitor;
 import org.apache.maven.shared.dependency.graph.traversal.FilteringDependencyNodeVisitor;


 /**
  * Apply clause-based filter over given dependencies
  *
  * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
  */
 public abstract class AbstractDependencyFilter
 {
     private static final Pattern MISSING_KEY_PATTERN = Pattern.compile( "(^|,)\\p{Blank}*(!)?\\p{Blank}*([a-zA-Z]+=)" );

     /**
      * Dependency Graph.
      */
     private final DependencyNode m_dependencyGraph;
     /**
      * Dependency artifacts.
      */
     private final Collection<Artifact> m_dependencyArtifacts;


     public AbstractDependencyFilter( DependencyNode dependencyGraph, Collection<Artifact> dependencyArtifacts )
     {
         m_dependencyGraph = dependencyGraph;
         m_dependencyArtifacts = dependencyArtifacts;
     }

     private static abstract class DependencyFilter implements ArtifactFilter
     {
         private final Instruction m_instruction;
         private final String m_defaultValue;


         public DependencyFilter( String expression )
         {
             this( expression, "" );
         }


         public DependencyFilter( String expression, String defaultValue )
         {
             m_instruction = new Instruction( expression );
             m_defaultValue = defaultValue;
         }

         public abstract boolean include( Artifact dependency );

         boolean matches( String text )
         {
             boolean result;

             if ( null == text )
             {
                 result = m_instruction.matches( m_defaultValue );
             }
             else
             {
                 result = m_instruction.matches( text );
             }

             return m_instruction.isNegated() ? !result : result;
         }
     }

     private static class TrimmingDependencyNodeFilter implements DependencyNodeFilter
     {
         private DependencyNodeFilter dependencyNodeFilter;

         public TrimmingDependencyNodeFilter( DependencyNodeFilter dependencyNodeFilter )
         {
             this.dependencyNodeFilter = dependencyNodeFilter;
         }

         public boolean accept( DependencyNode node )
         {
             boolean accepted = dependencyNodeFilter.accept( node );
             if( !accepted )
             {
                 List<DependencyNode> children = node.getChildren();
                 children.clear();
             }
             return accepted;
         }
     }

     protected final void processInstructions( String header ) throws MojoExecutionException
     {
         Map<String,Attrs> instructions = OSGiHeader.parseHeader( MISSING_KEY_PATTERN.matcher( header ).replaceAll( "$1$2*;$3" ) );

         Collection<Artifact> availableDependencies = new LinkedHashSet<Artifact>( m_dependencyArtifacts );

         for ( Iterator<Map.Entry<String,Attrs>> clauseIterator = instructions.entrySet().iterator(); clauseIterator.hasNext(); )
         {
             String inline = "false";

             // always start with a fresh *modifiable* collection for each unique clause
             Collection<Artifact> filteredDependencies = new LinkedHashSet<Artifact>( availableDependencies );

             // CLAUSE: REGEXP --> { ATTRIBUTE MAP }
             Map.Entry<String,Attrs> clause = clauseIterator.next();
             String primaryKey = clause.getKey().replaceFirst( "~+$", "" );
             boolean isNegative = primaryKey.startsWith( "!" );
             if ( isNegative )
             {
                 primaryKey = primaryKey.substring( 1 );
             }

             final AndArtifactFilter andArtifactFilter = new AndArtifactFilter();
             if ( !"*".equals( primaryKey ) )
             {
                 ArtifactFilter filter = new DependencyFilter( primaryKey )
                 {
                     @Override
                     public boolean include( Artifact dependency )
                     {
                         return super.matches( dependency.getArtifactId() );
                     }
                 };
                 // FILTER ON MAIN CLAUSE
                 andArtifactFilter.add(filter);
             }

             for ( Iterator<Map.Entry<String,String>> attrIterator = clause.getValue().entrySet().iterator(); attrIterator.hasNext(); )
             {
                 final ArtifactFilter filter;
                 // ATTRIBUTE: KEY --> REGEXP
                 Map.Entry<String,String> attr = attrIterator.next();
                 if ( "groupId".equals( attr.getKey() ) )
                 {
                     filter = new DependencyFilter( attr.getValue() )
                     {
                         @Override
                         public boolean include( Artifact dependency )
                         {
                             return super.matches( dependency.getGroupId() );
                         }
                     };
                 }
                 else if ( "artifactId".equals( attr.getKey() ) )
                 {
                     filter = new DependencyFilter( attr.getValue() )
                     {
                         @Override
                         public boolean include( Artifact dependency )
                         {
                             return super.matches( dependency.getArtifactId() );
                         }
                     };
                 }
                 else if ( "version".equals( attr.getKey() ) )
                 {
                     filter = new DependencyFilter( attr.getValue() )
                     {
                         @Override
                         public boolean include( Artifact dependency )
                         {
                             try
                             {
                                 // use the symbolic version if available (ie. 1.0.0-SNAPSHOT)
                                 return super.matches( dependency.getSelectedVersion().toString() );
                             }
                             catch ( Exception e )
                             {
                                 return super.matches( dependency.getVersion() );
                             }
                         }
                     };
                 }
                 else if ( "scope".equals( attr.getKey() ) )
                 {
                     filter = new DependencyFilter( attr.getValue(), "compile" )
                     {
                         @Override
                         public boolean include( Artifact dependency )
                         {
                             return super.matches( dependency.getScope() );
                         }
                     };
                 }
                 else if ( "type".equals( attr.getKey() ) )
                 {
                     filter = new DependencyFilter( attr.getValue(), "jar" )
                     {
                         @Override
                         public boolean include( Artifact dependency )
                         {
                             return super.matches( dependency.getType() );
                         }
                     };
                 }
                 else if ( "classifier".equals( attr.getKey() ) )
                 {
                     filter = new DependencyFilter( attr.getValue() )
                     {
                         @Override
                         public boolean include( Artifact dependency )
                         {
                             return super.matches( dependency.getClassifier() );
                         }
                     };
                 }
                 else if ( "optional".equals( attr.getKey() ) )
                 {
                     filter = new DependencyFilter( attr.getValue(), "false" )
                     {
                         @Override
                         public boolean include( Artifact dependency )
                         {
                             return super.matches( "" + dependency.isOptional() );
                         }
                     };
                 }
                 else if ( "inline".equals( attr.getKey() ) )
                 {
                     inline = attr.getValue();
                     continue;
                 }
                 else
                 {
                     throw new MojoExecutionException( "Unexpected attribute " + attr.getKey() );
                 }

                 // FILTER ON EACH ATTRIBUTE
                 andArtifactFilter.add( filter );
             }

             filteredDependencies( andArtifactFilter, filteredDependencies );

             if ( isNegative )
             {
                 // negative clauses reduce the set of available artifacts
                 availableDependencies.removeAll( filteredDependencies );
                 if ( !clauseIterator.hasNext() )
                 {
                     // assume there's an implicit * missing at the end
                     processDependencies( availableDependencies, inline );
                 }
             }
             else
             {
                 // positive clause; doesn't alter the available artifacts
                 processDependencies( filteredDependencies, inline );
             }
         }
     }


     protected abstract void processDependencies( Collection<Artifact> dependencies, String inline );

     private void filteredDependencies( final ArtifactFilter artifactFilter, Collection<Artifact> filteredDependencies )
     {
         CollectingDependencyNodeVisitor collectingDependencyNodeVisitor = new CollectingDependencyNodeVisitor();
         final Artifact rootArtifact = m_dependencyGraph.getArtifact();
         ArtifactFilter filter = new ArtifactFilter()
         {


             public boolean include( Artifact artifact )
             {
                 return artifact.equals( rootArtifact ) || artifactFilter.include( artifact );
             }


         };
         DependencyNodeFilter dependencyNodeFilter = new ArtifactDependencyNodeFilter( filter );
         dependencyNodeFilter = new TrimmingDependencyNodeFilter( dependencyNodeFilter );
         DependencyNodeVisitor dependencyNodeVisitor =
                 new FilteringDependencyNodeVisitor( collectingDependencyNodeVisitor, dependencyNodeFilter );
         dependencyNodeVisitor = new BuildingDependencyNodeVisitor( dependencyNodeVisitor );
         m_dependencyGraph.accept( dependencyNodeVisitor );
         List<DependencyNode> dependencyNodes = collectingDependencyNodeVisitor.getNodes();
         Set<String> ids = new LinkedHashSet<String>( dependencyNodes.size() );
         for( DependencyNode dependencyNode : dependencyNodes ) {
             Artifact artifact = dependencyNode.getArtifact();
             String id = artifact.getId();
             ids.add(id);
         }
         for (Iterator<Artifact> iterator = filteredDependencies.iterator(); iterator.hasNext();)
         {
             Artifact artifact = iterator.next();
             String id = artifact.getId();
             if (!ids.contains(id))
             {
                 iterator.remove();
             }
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.felix.bundleplugin;


	import java.util.Collection;
	import java.util.Iterator;
	import java.util.LinkedHashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.regex.Pattern;

	import org.apache.maven.artifact.Artifact;
	import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
	import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
	import org.apache.maven.plugin.MojoExecutionException;

	import aQute.bnd.header.Attrs;
	import aQute.bnd.header.OSGiHeader;
	import aQute.bnd.osgi.Instruction;
	import org.apache.maven.shared.dependency.graph.DependencyNode;
	import org.apache.maven.shared.dependency.graph.filter.ArtifactDependencyNodeFilter;
	import org.apache.maven.shared.dependency.graph.filter.DependencyNodeFilter;
	import org.apache.maven.shared.dependency.graph.traversal.BuildingDependencyNodeVisitor;
	import org.apache.maven.shared.dependency.graph.traversal.CollectingDependencyNodeVisitor;
	import org.apache.maven.shared.dependency.graph.traversal.DependencyNodeVisitor;
	import org.apache.maven.shared.dependency.graph.traversal.FilteringDependencyNodeVisitor;


	/**
	* Apply clause-based filter over given dependencies
	*
	* @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
	*/
	public abstract class AbstractDependencyFilter
	{
	private static final Pattern MISSING_KEY_PATTERN = Pattern.compile( "(^\|,)\\p{Blank}(!)?\\p{Blank}([a-zA-Z]+=)" );

	/**
	* Dependency Graph.
	*/
	private final DependencyNode m_dependencyGraph;
	/**
	* Dependency artifacts.
	*/
	private final Collection<Artifact> m_dependencyArtifacts;


	public AbstractDependencyFilter( DependencyNode dependencyGraph, Collection<Artifact> dependencyArtifacts )
	{
	m_dependencyGraph = dependencyGraph;
	m_dependencyArtifacts = dependencyArtifacts;
	}

	private static abstract class DependencyFilter implements ArtifactFilter
	{
	private final Instruction m_instruction;
	private final String m_defaultValue;


	public DependencyFilter( String expression )
	{
	this( expression, "" );
	}


	public DependencyFilter( String expression, String defaultValue )
	{
	m_instruction = new Instruction( expression );
	m_defaultValue = defaultValue;
	}

	public abstract boolean include( Artifact dependency );

	boolean matches( String text )
	{
	boolean result;

	if ( null == text )
	{
	result = m_instruction.matches( m_defaultValue );
	}
	else
	{
	result = m_instruction.matches( text );
	}

	return m_instruction.isNegated() ? !result : result;
	}
	}

	private static class TrimmingDependencyNodeFilter implements DependencyNodeFilter
	{
	private DependencyNodeFilter dependencyNodeFilter;

	public TrimmingDependencyNodeFilter( DependencyNodeFilter dependencyNodeFilter )
	{
	this.dependencyNodeFilter = dependencyNodeFilter;
	}

	public boolean accept( DependencyNode node )
	{
	boolean accepted = dependencyNodeFilter.accept( node );
	if( !accepted )
	{
	List<DependencyNode> children = node.getChildren();
	children.clear();
	}
	return accepted;
	}
	}

	protected final void processInstructions( String header ) throws MojoExecutionException
	{
	Map<String,Attrs> instructions = OSGiHeader.parseHeader( MISSING_KEY_PATTERN.matcher( header ).replaceAll( "$1$2*;$3" ) );

	Collection<Artifact> availableDependencies = new LinkedHashSet<Artifact>( m_dependencyArtifacts );

	for ( Iterator<Map.Entry<String,Attrs>> clauseIterator = instructions.entrySet().iterator(); clauseIterator.hasNext(); )
	{
	String inline = "false";

	// always start with a fresh modifiable collection for each unique clause
	Collection<Artifact> filteredDependencies = new LinkedHashSet<Artifact>( availableDependencies );

	// CLAUSE: REGEXP --> { ATTRIBUTE MAP }
	Map.Entry<String,Attrs> clause = clauseIterator.next();
	String primaryKey = clause.getKey().replaceFirst( "~+$", "" );
	boolean isNegative = primaryKey.startsWith( "!" );
	if ( isNegative )
	{
	primaryKey = primaryKey.substring( 1 );
	}

	final AndArtifactFilter andArtifactFilter = new AndArtifactFilter();
	if ( !"*".equals( primaryKey ) )
	{
	ArtifactFilter filter = new DependencyFilter( primaryKey )
	{
	@Override
	public boolean include( Artifact dependency )
	{
	return super.matches( dependency.getArtifactId() );
	}
	};
	// FILTER ON MAIN CLAUSE
	andArtifactFilter.add(filter);
	}

	for ( Iterator<Map.Entry<String,String>> attrIterator = clause.getValue().entrySet().iterator(); attrIterator.hasNext(); )
	{
	final ArtifactFilter filter;
	// ATTRIBUTE: KEY --> REGEXP
	Map.Entry<String,String> attr = attrIterator.next();
	if ( "groupId".equals( attr.getKey() ) )
	{
	filter = new DependencyFilter( attr.getValue() )
	{
	@Override
	public boolean include( Artifact dependency )
	{
	return super.matches( dependency.getGroupId() );
	}
	};
	}
	else if ( "artifactId".equals( attr.getKey() ) )
	{
	filter = new DependencyFilter( attr.getValue() )
	{
	@Override
	public boolean include( Artifact dependency )
	{
	return super.matches( dependency.getArtifactId() );
	}
	};
	}
	else if ( "version".equals( attr.getKey() ) )
	{
	filter = new DependencyFilter( attr.getValue() )
	{
	@Override
	public boolean include( Artifact dependency )
	{
	try
	{
	// use the symbolic version if available (ie. 1.0.0-SNAPSHOT)
	return super.matches( dependency.getSelectedVersion().toString() );
	}
	catch ( Exception e )
	{
	return super.matches( dependency.getVersion() );
	}
	}
	};
	}
	else if ( "scope".equals( attr.getKey() ) )
	{
	filter = new DependencyFilter( attr.getValue(), "compile" )
	{
	@Override
	public boolean include( Artifact dependency )
	{
	return super.matches( dependency.getScope() );
	}
	};
	}
	else if ( "type".equals( attr.getKey() ) )
	{
	filter = new DependencyFilter( attr.getValue(), "jar" )
	{
	@Override
	public boolean include( Artifact dependency )
	{
	return super.matches( dependency.getType() );
	}
	};
	}
	else if ( "classifier".equals( attr.getKey() ) )
	{
	filter = new DependencyFilter( attr.getValue() )
	{
	@Override
	public boolean include( Artifact dependency )
	{
	return super.matches( dependency.getClassifier() );
	}
	};
	}
	else if ( "optional".equals( attr.getKey() ) )
	{
	filter = new DependencyFilter( attr.getValue(), "false" )
	{
	@Override
	public boolean include( Artifact dependency )
	{
	return super.matches( "" + dependency.isOptional() );
	}
	};
	}
	else if ( "inline".equals( attr.getKey() ) )
	{
	inline = attr.getValue();
	continue;
	}
	else
	{
	throw new MojoExecutionException( "Unexpected attribute " + attr.getKey() );
	}

	// FILTER ON EACH ATTRIBUTE
	andArtifactFilter.add( filter );
	}

	filteredDependencies( andArtifactFilter, filteredDependencies );

	if ( isNegative )
	{
	// negative clauses reduce the set of available artifacts
	availableDependencies.removeAll( filteredDependencies );
	if ( !clauseIterator.hasNext() )
	{
	// assume there's an implicit * missing at the end
	processDependencies( availableDependencies, inline );
	}
	}
	else
	{
	// positive clause; doesn't alter the available artifacts
	processDependencies( filteredDependencies, inline );
	}
	}
	}


	protected abstract void processDependencies( Collection<Artifact> dependencies, String inline );

	private void filteredDependencies( final ArtifactFilter artifactFilter, Collection<Artifact> filteredDependencies )
	{
	CollectingDependencyNodeVisitor collectingDependencyNodeVisitor = new CollectingDependencyNodeVisitor();
	final Artifact rootArtifact = m_dependencyGraph.getArtifact();
	ArtifactFilter filter = new ArtifactFilter()
	{


	public boolean include( Artifact artifact )
	{
	return artifact.equals( rootArtifact ) \|\| artifactFilter.include( artifact );
	}


	};
	DependencyNodeFilter dependencyNodeFilter = new ArtifactDependencyNodeFilter( filter );
	dependencyNodeFilter = new TrimmingDependencyNodeFilter( dependencyNodeFilter );
	DependencyNodeVisitor dependencyNodeVisitor =
	new FilteringDependencyNodeVisitor( collectingDependencyNodeVisitor, dependencyNodeFilter );
	dependencyNodeVisitor = new BuildingDependencyNodeVisitor( dependencyNodeVisitor );
	m_dependencyGraph.accept( dependencyNodeVisitor );
	List<DependencyNode> dependencyNodes = collectingDependencyNodeVisitor.getNodes();
	Set<String> ids = new LinkedHashSet<String>( dependencyNodes.size() );
	for( DependencyNode dependencyNode : dependencyNodes ) {
	Artifact artifact = dependencyNode.getArtifact();
	String id = artifact.getId();
	ids.add(id);
	}
	for (Iterator<Artifact> iterator = filteredDependencies.iterator(); iterator.hasNext();)
	{
	Artifact artifact = iterator.next();
	String id = artifact.getId();
	if (!ids.contains(id))
	{
	iterator.remove();
	}
	}
	}
	}