AbstractIteratorMojo.java
package com.soebes.maven.plugins.iterator;
/*
* 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.Collections;
import java.util.Comparator;
import java.util.List;
import org.apache.commons.io.comparator.NameFileComparator;
import org.apache.commons.io.filefilter.DirectoryFileFilter;
import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.filefilter.HiddenFileFilter;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.project.MavenProject;
/**
* @author Karl-Heinz Marbaise <a href="mailto:khmarbaise@apache.org">khmarbaise@apache.org</a>
*/
public abstract class AbstractIteratorMojo
extends AbstractMojo
{
/**
* The project currently being build.
*/
@Parameter( required = true, readonly = true, defaultValue = "${project}" )
private MavenProject mavenProject;
/**
* The current Maven session.
*/
@Parameter( required = true, readonly = true, defaultValue = "${session}" )
private MavenSession mavenSession;
/**
* If you like to skip the execution.
*/
@Parameter( property = "iterator.skip", defaultValue = "false" )
private boolean skip;
/**
* Fail the execution at the end of all iterations or fail the whole if one iteration step fails.
*/
@Parameter( property = "iterator.failAtEnd", defaultValue = "false" )
private boolean failAtEnd;
/**
* The token the iterator placeholder begins with.
*/
@Parameter( required = true, defaultValue = "@" )
private String beginToken;
/**
* The token the iterator placeholder ends with.
*/
@Parameter( required = true, defaultValue = "@" )
private String endToken;
/**
* The name of the iterator variable.
*/
@Parameter( required = true, defaultValue = "item" )
private String iteratorName;
/**
* Here you can define the items which will be iterated through.
*
* <pre>
* {@code
* <items>
* <item>one</item>
* <item>two</item>
* <item>three</item>
* ..
* </items>}
* </pre>
*/
@Parameter( property = "iterator.items" )
private List<String> items;
/**
* If you like to have items to iterate through which also contain supplemental properties. This can be done by
* using the following:
*
* <pre>
* {@code
* <itemsWithProperties>
* <itemWithProperty>
* <name>one</name>
* <properties>
* <xyz>google</xyz>
* </properties>
* </itemWithProperty>
* <itemWithProperty>
* <name>two</name>
* <properties>
* <xyz>theseverside</xyz>
* </properties>
* </itemWithProperty>
* ..
* </items>}
* </pre>
*
* You are not determined having the same properties for the iterations. You can use different properties for each
* iteration.
*/
@Parameter
private List<ItemWithProperties> itemsWithProperties;
/**
* The list of items which will be iterated through. {@code <content>one, two, three</content>}
*/
@Parameter
private String content;
/**
* The delimiter which will be used to split the {@link #content}.
*/
@Parameter( defaultValue = "," )
private String delimiter;
/**
* By using this folder you define a folder which sub folders will be used to iterate over. It will be iterated over
* the directories but not the sub folders so no recursion will be done. The order of the iterated elements is done
* by {@link #sortOrder}.
*/
@Parameter
private File folder;
/**
* This defines the sort order for the folders which will be iterated over.
* {@link NameFileComparator#NAME_COMPARATOR} {@link NameFileComparator#NAME_INSENSITIVE_COMPARATOR}
* {@link NameFileComparator#NAME_INSENSITIVE_REVERSE} {@link NameFileComparator#NAME_REVERSE}
* {@link NameFileComparator#NAME_SYSTEM_COMPARATOR} {@link NameFileComparator#NAME_SYSTEM_REVERSE}
*/
@Parameter( defaultValue = "NAME_COMPARATOR" )
private String sortOrder;
public boolean isSortOrderValid( String sortOrder )
{
boolean result = sortOrder.equalsIgnoreCase( "NAME_COMPARATOR" )
|| sortOrder.equalsIgnoreCase( "NAME_INSENSITIVE_COMPARATOR" )
|| sortOrder.equalsIgnoreCase( "NAME_INSENSITIVE_REVERSE" ) || sortOrder.equalsIgnoreCase( "NAME_REVERSE" )
|| sortOrder.equalsIgnoreCase( "NAME_SYSTEM_COMPARATOR" )
|| sortOrder.equalsIgnoreCase( "NAME_SYSTEM_REVERSE" );
return result;
}
protected Comparator<File> convertSortOrder()
{
Comparator<File> result = NameFileComparator.NAME_COMPARATOR;
if ( getSortOrder().equalsIgnoreCase( "NAME_INSENSITIVE_COMPARATOR" ) )
{
result = NameFileComparator.NAME_INSENSITIVE_COMPARATOR;
}
else if ( getSortOrder().equalsIgnoreCase( "NAME_INSENSITIVE_REVERSE" ) )
{
result = NameFileComparator.NAME_INSENSITIVE_REVERSE;
}
else if ( getSortOrder().equalsIgnoreCase( "NAME_REVERSE" ) )
{
result = NameFileComparator.NAME_REVERSE;
}
else if ( getSortOrder().equalsIgnoreCase( "NAME_SYSTEM_COMPARATOR" ) )
{
result = NameFileComparator.NAME_SYSTEM_COMPARATOR;
}
else if ( getSortOrder().equalsIgnoreCase( "NAME_SYSTEM_REVERSE" ) )
{
result = NameFileComparator.NAME_SYSTEM_REVERSE;
}
return result;
}
public List<String> getFolders()
throws MojoExecutionException
{
IOFileFilter folders = FileFilterUtils.and( HiddenFileFilter.VISIBLE, DirectoryFileFilter.DIRECTORY );
IOFileFilter makeSVNAware = FileFilterUtils.makeSVNAware( folders );
IOFileFilter makeCVSAware = FileFilterUtils.makeCVSAware( makeSVNAware );
String[] list = folder.list( makeCVSAware );
if ( list == null )
{
throw new MojoExecutionException( "The specified folder doesn't exist: " + folder );
}
List<File> listOfDirectories = new ArrayList<File>();
for ( String item : list )
{
listOfDirectories.add( new File( folder, item ) );
}
Collections.sort( listOfDirectories, convertSortOrder() );
List<String> resultList = new ArrayList<String>();
for ( File file : listOfDirectories )
{
resultList.add( file.getName() );
}
return resultList;
}
private List<String> getContentAsList()
{
List<String> result = new ArrayList<String>();
String[] resultArray = content.split( delimiter );
for ( String item : resultArray )
{
result.add( item.trim() );
}
return result;
}
/**
* Convert all types {@code content}, {@code items} or {@code ItemsWithProperties} into the same type.
*
* @return list {@link ItemWithProperties}
* @throws MojoExecutionException In case of an error.
*/
protected List<ItemWithProperties> getItemsConverted()
throws MojoExecutionException
{
List<ItemWithProperties> result = new ArrayList<>();
if ( isItemsWithPropertiesSet() )
{
result = getItemsWithProperties();
}
else if ( isContentSet() )
{
for ( String itemName : getContentAsList() )
{
result.add( new ItemWithProperties( itemName, ItemWithProperties.NO_PROPERTIES ) );
}
}
else if ( isItemsSet() )
{
for ( String itemName : getItems() )
{
result.add( new ItemWithProperties( itemName, ItemWithProperties.NO_PROPERTIES ) );
}
}
else if ( isFolderSet() )
{
for ( String itemName : getFolders() )
{
result.add( new ItemWithProperties( itemName, ItemWithProperties.NO_PROPERTIES ) );
}
}
return result;
}
/**
* This is just a convenience method to get the combination of {@link #getBeginToken()}, {@link #getIteratorName()}
* and {@link #getEndToken()}.
*
* @return The combined string.
*/
protected String getPlaceHolder()
{
return getBeginToken() + getIteratorName() + getEndToken();
}
protected boolean isItemsNull()
{
return items == null;
}
protected boolean isItemsWithPropertiesNull()
{
return itemsWithProperties == null;
}
protected boolean isItemsWithPropertiesSet()
{
return !isItemsWithPropertiesNull() && !itemsWithProperties.isEmpty();
}
protected boolean isItemsSet()
{
return !isItemsNull() && !items.isEmpty();
}
protected boolean isContentNull()
{
return content == null;
}
protected boolean isContentSet()
{
// @TODO: Check if content.trim() couldn't be done more efficient?
return content != null && content.trim().length() > 0;
}
protected boolean isFolderSet()
{
return this.folder != null;
}
protected boolean isFolderNull()
{
return this.folder == null;
}
public File getFolder()
{
return this.folder;
}
public void setFolder( File folder )
{
this.folder = folder;
}
protected boolean isMoreThanOneSet()
{
// a ^ b ^ c && ! (a && b && c)
boolean result = isItemsSet() ^ isContentSet() ^ isItemsWithPropertiesSet() ^ isFolderSet()
&& !( isItemsSet() && isContentSet() && isItemsWithPropertiesSet() && isFolderSet() );
return !result;
}
protected boolean isNoneSet()
{
return isItemsNull() && isContentNull() && isItemsWithPropertiesNull() && isFolderNull();
}
public void setSortOrder( String sortOrder )
{
this.sortOrder = sortOrder;
}
public String getSortOrder()
{
return sortOrder;
}
public String getContent()
{
return content;
}
public void setContent( String content )
{
this.content = content;
}
public String getDelimiter()
{
return delimiter;
}
public void setDelimiter( String delimiter )
{
this.delimiter = delimiter;
}
public String getBeginToken()
{
return beginToken;
}
public void setBeginToken( String beginToken )
{
this.beginToken = beginToken;
}
public String getEndToken()
{
return endToken;
}
public void setEndToken( String endToken )
{
this.endToken = endToken;
}
public String getIteratorName()
{
return iteratorName;
}
public void setIteratorName( String iteratorName )
{
this.iteratorName = iteratorName;
}
public void setItems( List<String> items )
{
this.items = items;
}
public List<String> getItems()
{
return items;
}
public boolean isSkip()
{
return skip;
}
public boolean isFailAtEnd()
{
return failAtEnd;
}
public List<ItemWithProperties> getItemsWithProperties()
{
return itemsWithProperties;
}
public void setItemsWithProperties( List<ItemWithProperties> itemsWithProperties )
{
this.itemsWithProperties = itemsWithProperties;
}
public MavenProject getMavenProject()
{
return mavenProject;
}
public void setMavenProject( MavenProject mavenProject )
{
this.mavenProject = mavenProject;
}
public MavenSession getMavenSession()
{
return mavenSession;
}
public void setMavenSession( MavenSession mavenSession )
{
this.mavenSession = mavenSession;
}
}