/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at
|
* trunk/opends/resource/legal-notices/CDDLv1_0.txt
|
* or http://forgerock.org/license/CDDLv1.0.html.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at
|
* trunk/opends/resource/legal-notices/CDDLv1_0.txt. If applicable,
|
* add the following below this CDDL HEADER, with the fields enclosed
|
* by brackets "[]" replaced with your own identifying information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
* Copyright 2011 ForgeRock AS
|
*/
|
package org.opendj.buildtools.maven;
|
|
|
|
import java.io.*;
|
import java.nio.charset.Charset;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
import org.apache.maven.plugin.AbstractMojo;
|
import org.apache.maven.plugin.MojoExecutionException;
|
import org.apache.maven.project.MavenProject;
|
|
|
|
/**
|
* Goal which generates message source files from a one or more property files.
|
*
|
* @goal generatemessages
|
* @phase generate-sources
|
* @requiresDependencyResolution compile
|
* @threadSafe
|
*/
|
public class GenerateMessagesMojo extends AbstractMojo
|
{
|
/**
|
* Representation of a format specifier (for example %s).
|
*/
|
private class FormatSpecifier
|
{
|
|
private final String[] sa;
|
|
|
|
/**
|
* Creates a new specifier.
|
*
|
* @param sa
|
* specifier components
|
*/
|
FormatSpecifier(final String[] sa)
|
{
|
this.sa = sa;
|
}
|
|
|
|
/**
|
* Returns a java class associated with a particular formatter based on the
|
* conversion type of the specifier.
|
*
|
* @return Class for representing the type of argument used as a replacement
|
* for this specifier.
|
*/
|
Class<?> getSimpleConversionClass()
|
{
|
Class<?> c = null;
|
final String sa4 = sa[4] != null ? sa[4].toLowerCase() : null;
|
final String sa5 = sa[5] != null ? sa[5].toLowerCase() : null;
|
if ("t".equals(sa4))
|
{
|
c = Calendar.class;
|
}
|
else if ("b".equals(sa5))
|
{
|
c = Boolean.class;
|
}
|
else if ("h".equals(sa5))
|
{
|
c = Integer.class;
|
}
|
else if ("s".equals(sa5))
|
{
|
c = CharSequence.class;
|
}
|
else if ("c".equals(sa5))
|
{
|
c = Character.class;
|
}
|
else if ("d".equals(sa5) || "o".equals(sa5) || "x".equals(sa5)
|
|| "e".equals(sa5) || "f".equals(sa5) || "g".equals(sa5)
|
|| "a".equals(sa5))
|
{
|
c = Number.class;
|
}
|
else if ("n".equals(sa5) || "%".equals(sa5))
|
{
|
// ignore literals
|
}
|
return c;
|
}
|
|
|
|
/**
|
* Indicates whether or not the specifier uses argument indexes (for example
|
* 2$).
|
*
|
* @return boolean true if this specifier uses indexing
|
*/
|
boolean specifiesArgumentIndex()
|
{
|
return this.sa[0] != null;
|
}
|
|
}
|
|
|
|
/**
|
* Represents a message to be written into the messages files.
|
*/
|
private class MessageDescriptorDeclaration
|
{
|
|
private final MessagePropertyKey key;
|
|
private final String formatString;
|
|
private final List<FormatSpecifier> specifiers;
|
|
private final List<Class<?>> classTypes;
|
|
private String[] constructorArgs;
|
|
|
|
/**
|
* Creates a parameterized instance.
|
*
|
* @param key
|
* of the message
|
* @param formatString
|
* of the message
|
*/
|
MessageDescriptorDeclaration(final MessagePropertyKey key,
|
final String formatString)
|
{
|
this.key = key;
|
this.formatString = formatString;
|
this.specifiers = parse(formatString);
|
this.classTypes = new ArrayList<Class<?>>();
|
for (final FormatSpecifier f : specifiers)
|
{
|
final Class<?> c = f.getSimpleConversionClass();
|
if (c != null)
|
{
|
classTypes.add(c);
|
}
|
}
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public String toString()
|
{
|
final StringBuilder sb = new StringBuilder();
|
sb.append(getComment());
|
sb.append(indent(1));
|
sb.append("public static final ");
|
sb.append(getDescriptorClassDeclaration());
|
sb.append(" ");
|
sb.append(key.getMessageDescriptorName());
|
sb.append(" =");
|
sb.append(EOL);
|
sb.append(indent(5));
|
sb.append("new ");
|
sb.append(getDescriptorClassDeclaration());
|
sb.append("(");
|
if (constructorArgs != null)
|
{
|
for (int i = 0; i < constructorArgs.length; i++)
|
{
|
sb.append(constructorArgs[i]);
|
if (i < constructorArgs.length - 1)
|
{
|
sb.append(",");
|
}
|
}
|
sb.append(", ");
|
}
|
sb.append("getClassLoader()");
|
sb.append(");");
|
return sb.toString();
|
}
|
|
|
|
/**
|
* Gets a string representing the message type class' variable information
|
* (for example '<String,Integer>') that is based on the type of arguments
|
* specified by the specifiers in this message.
|
*
|
* @return String representing the message type class parameters
|
*/
|
String getClassTypeVariables()
|
{
|
final StringBuilder sb = new StringBuilder();
|
if (classTypes.size() > 0)
|
{
|
sb.append("<");
|
for (int i = 0; i < classTypes.size(); i++)
|
{
|
final Class<?> c = classTypes.get(i);
|
if (c != null)
|
{
|
sb.append(getShortClassName(c));
|
if (i < classTypes.size() - 1)
|
{
|
sb.append(",");
|
}
|
}
|
}
|
sb.append(">");
|
}
|
return sb.toString();
|
}
|
|
|
|
/**
|
* Gets the javadoc comments that will appear above the messages declaration
|
* in the messages file.
|
*
|
* @return String comment
|
*/
|
String getComment()
|
{
|
final StringBuilder sb = new StringBuilder();
|
sb.append(indent(1)).append("/**").append(EOL);
|
|
// Unwrapped so that you can search through the descriptor
|
// file for a message and not have to worry about line breaks
|
final String ws = formatString; // wrapText(formatString, 70);
|
|
final String[] sa = ws.split(EOL);
|
for (final String s : sa)
|
{
|
sb.append(indent(1)).append(" * ").append(s).append(EOL);
|
}
|
sb.append(indent(1)).append(" */").append(EOL);
|
return sb.toString();
|
}
|
|
|
|
/**
|
* Gets the name of the Java class that will be used to represent this
|
* message's type.
|
*
|
* @return String representing the Java class name
|
*/
|
String getDescriptorClassDeclaration()
|
{
|
final StringBuilder sb = new StringBuilder();
|
if (useGenericMessageTypeClass())
|
{
|
sb.append("LocalizableMessageDescriptor");
|
sb.append(".");
|
sb.append(DESCRIPTOR_CLASS_BASE_NAME);
|
sb.append("N");
|
}
|
else
|
{
|
sb.append("LocalizableMessageDescriptor");
|
sb.append(".");
|
sb.append(DESCRIPTOR_CLASS_BASE_NAME);
|
sb.append(classTypes.size());
|
sb.append(getClassTypeVariables());
|
}
|
return sb.toString();
|
}
|
|
|
|
/**
|
* Sets the arguments that will be supplied in the declaration of the
|
* message.
|
*
|
* @param s
|
* array of string arguments that will be passed in the constructor
|
*/
|
void setConstructorArguments(final String... s)
|
{
|
this.constructorArgs = s;
|
}
|
|
|
|
private void checkText(final String s)
|
{
|
int idx;
|
// If there are any '%' in the given string, we got a bad format
|
// specifier.
|
if ((idx = s.indexOf('%')) != -1)
|
{
|
final char c = (idx > s.length() - 2 ? '%' : s.charAt(idx + 1));
|
throw new UnknownFormatConversionException(String.valueOf(c));
|
}
|
}
|
|
|
|
private String getShortClassName(final Class<?> c)
|
{
|
String name;
|
final String fqName = c.getName();
|
final int i = fqName.lastIndexOf('.');
|
if (i > 0)
|
{
|
name = fqName.substring(i + 1);
|
}
|
else
|
{
|
name = fqName;
|
}
|
return name;
|
}
|
|
|
|
private String indent(final int indent)
|
{
|
final char[] blankArray = new char[2 * indent];
|
Arrays.fill(blankArray, ' ');
|
return new String(blankArray);
|
}
|
|
|
|
/**
|
* Look for format specifiers in the format string.
|
*
|
* @param s
|
* format string
|
* @return list of format specifiers
|
*/
|
private List<FormatSpecifier> parse(final String s)
|
{
|
final List<FormatSpecifier> sl = new ArrayList<FormatSpecifier>();
|
final Matcher m = SPECIFIER_PATTERN.matcher(s);
|
int i = 0;
|
while (i < s.length())
|
{
|
if (m.find(i))
|
{
|
// Anything between the start of the string and the beginning
|
// of the format specifier is either fixed text or contains
|
// an invalid format string.
|
if (m.start() != i)
|
{
|
// Make sure we didn't miss any invalid format specifiers
|
checkText(s.substring(i, m.start()));
|
// Assume previous characters were fixed text
|
// al.add(new FixedString(s.substring(i, m.start())));
|
}
|
|
// Expect 6 groups in regular expression
|
final String[] sa = new String[6];
|
for (int j = 0; j < m.groupCount(); j++)
|
{
|
sa[j] = m.group(j + 1);
|
}
|
sl.add(new FormatSpecifier(sa));
|
i = m.end();
|
}
|
else
|
{
|
// No more valid format specifiers. Check for possible invalid
|
// format specifiers.
|
checkText(s.substring(i));
|
// The rest of the string is fixed text
|
// al.add(new FixedString(s.substring(i)));
|
break;
|
}
|
}
|
return sl;
|
}
|
|
|
|
/**
|
* Indicates whether the generic message type class should be used. In
|
* general this is when a format specifier is more complicated than we
|
* support or when the number of arguments exceeeds the number of specific
|
* message type classes (MessageType0, MessageType1 ...) that are defined.
|
*
|
* @return boolean indicating
|
*/
|
private boolean useGenericMessageTypeClass()
|
{
|
if (specifiers.size() > DESCRIPTOR_MAX_ARG_HANDLER)
|
{
|
return true;
|
}
|
else if (specifiers != null)
|
{
|
for (final FormatSpecifier s : specifiers)
|
{
|
if (s.specifiesArgumentIndex())
|
{
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
}
|
|
|
|
/**
|
* The destination directory.
|
*
|
* @parameter
|
* default-value="${project.build.directory}/generated-sources/messages"
|
* @required
|
*/
|
private File outputDirectory;
|
|
/**
|
* The source directory.
|
*
|
* @parameter default-value="${basedir}/src/main/resources"
|
* @required
|
*/
|
private File sourceDirectory;
|
|
/**
|
* Indicates whether or not message source files should be regenerated even if
|
* they are already up to date.
|
*
|
* @parameter default-value="false"
|
* @required
|
*/
|
private boolean force;
|
|
/**
|
* The list of files we want to transfer, relative to the source directory.
|
*
|
* @parameter
|
* @required
|
*/
|
private List<MessageFile> messageFiles;
|
|
/**
|
* The current Maven project.
|
*
|
* @parameter default-value="${project}"
|
* @readonly
|
* @required
|
*/
|
private MavenProject project;
|
|
/**
|
* The base name of the specific argument handling subclasses defined below.
|
* The class names consist of the base name followed by a number indicating
|
* the number of arguments that they handle when creating messages or the
|
* letter "N" meaning any number of arguments.
|
*/
|
private static final String DESCRIPTOR_CLASS_BASE_NAME = "Arg";
|
|
/**
|
* The maximum number of arguments that can be handled by a specific subclass.
|
* If you define more subclasses be sure to increment this number
|
* appropriately.
|
*/
|
private static final int DESCRIPTOR_MAX_ARG_HANDLER = 11;
|
|
private static final String SPECIFIER_REGEX = "%(\\d+\\$)?([-#+ 0,(\\<]*)?(\\d+)?(\\.\\d+)?([tT])?([a-zA-Z%])";
|
|
private static final Pattern SPECIFIER_PATTERN = Pattern
|
.compile(SPECIFIER_REGEX);
|
|
/**
|
* The end-of-line character for this platform.
|
*/
|
private static final String EOL = System.getProperty("line.separator");
|
|
/**
|
* The UTF-8 character set used for encoding/decoding files.
|
*/
|
private static final Charset UTF_8 = Charset.forName("UTF-8");
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public void execute() throws MojoExecutionException
|
{
|
if (!sourceDirectory.exists())
|
{
|
throw new MojoExecutionException("Source directory "
|
+ sourceDirectory.getPath() + " does not exist");
|
}
|
else if (!sourceDirectory.isDirectory())
|
{
|
throw new MojoExecutionException("Source directory "
|
+ sourceDirectory.getPath() + " is not a directory");
|
}
|
|
if (!outputDirectory.exists())
|
{
|
if (outputDirectory.mkdirs())
|
{
|
getLog().info(
|
"Created message output directory: " + outputDirectory.getPath());
|
}
|
else
|
{
|
throw new MojoExecutionException(
|
"Unable to create message output directory: "
|
+ outputDirectory.getPath());
|
}
|
}
|
else if (!outputDirectory.isDirectory())
|
{
|
throw new MojoExecutionException("Output directory "
|
+ outputDirectory.getPath() + " is not a directory");
|
}
|
|
if (project != null)
|
{
|
getLog().info("Adding source directory: " + outputDirectory.getPath());
|
project.addCompileSourceRoot(outputDirectory.getAbsolutePath());
|
}
|
|
for (final MessageFile messageFile : messageFiles)
|
{
|
processMessageFile(messageFile);
|
}
|
}
|
|
|
|
/*
|
* Returns the message Java stub file from this plugin's resources.
|
*/
|
private InputStream getStubFile() throws MojoExecutionException
|
{
|
return getClass().getResourceAsStream("Messages.java.stub");
|
}
|
|
|
|
private void processMessageFile(final MessageFile messageFile)
|
throws MojoExecutionException
|
{
|
final File sourceFile = messageFile.getSourceFile(sourceDirectory);
|
final File outputFile = messageFile.getOutputFile(outputDirectory);
|
|
// Decide whether to generate messages based on modification
|
// times and print status messages.
|
if (!sourceFile.exists())
|
{
|
throw new MojoExecutionException("Message file " + messageFile.getName()
|
+ " does not exist");
|
}
|
|
if (outputFile.exists())
|
{
|
if (force || sourceFile.lastModified() > outputFile.lastModified())
|
{
|
outputFile.delete();
|
getLog().info(
|
"Regenerating " + outputFile.getName() + " from "
|
+ sourceFile.getName());
|
}
|
else
|
{
|
getLog().info(outputFile.getName() + " is up to date");
|
return;
|
}
|
}
|
else
|
{
|
final File packageDirectory = outputFile.getParentFile();
|
if (!packageDirectory.exists())
|
{
|
if (!packageDirectory.mkdirs())
|
{
|
throw new MojoExecutionException(
|
"Unable to create message output directory: "
|
+ packageDirectory.getPath());
|
}
|
}
|
getLog().info(
|
"Generating " + outputFile.getName() + " from "
|
+ sourceFile.getName());
|
}
|
|
BufferedReader stubReader = null;
|
PrintWriter outputWriter = null;
|
|
try
|
{
|
stubReader = new BufferedReader(new InputStreamReader(getStubFile(),
|
UTF_8));
|
outputWriter = new PrintWriter(outputFile, "UTF-8");
|
|
final Properties properties = new Properties();
|
properties.load(new FileInputStream(sourceFile));
|
|
for (String stubLine = stubReader.readLine(); stubLine != null; stubLine = stubReader
|
.readLine())
|
{
|
if (stubLine.contains("${MESSAGES}"))
|
{
|
final Map<MessagePropertyKey, String> keyMap = new TreeMap<MessagePropertyKey, String>();
|
|
for (final Object propO : properties.keySet())
|
{
|
final String propKey = propO.toString();
|
final MessagePropertyKey key = MessagePropertyKey
|
.parseString(propKey);
|
final String formatString = properties.getProperty(propKey);
|
keyMap.put(key, formatString);
|
}
|
|
int usesOfGenericDescriptor = 0;
|
|
for (final MessagePropertyKey key : keyMap.keySet())
|
{
|
final String formatString = keyMap.get(key);
|
final MessageDescriptorDeclaration message = new MessageDescriptorDeclaration(
|
key, formatString);
|
|
message.setConstructorArguments("BASE", quote(key.toString()));
|
outputWriter.println(message.toString());
|
outputWriter.println();
|
|
// Keep track of when we use the generic descriptor so that we can
|
// report it later
|
if (message.useGenericMessageTypeClass())
|
{
|
usesOfGenericDescriptor++;
|
}
|
}
|
|
getLog().debug(" LocalizableMessage Generated:" + keyMap.size());
|
getLog().debug(
|
" LocalizableMessageDescriptor.ArgN:" + usesOfGenericDescriptor);
|
|
}
|
else
|
{
|
stubLine = stubLine.replace("${PACKAGE}",
|
messageFile.getPackageName());
|
stubLine = stubLine.replace("${CLASS_NAME}",
|
messageFile.getClassName());
|
stubLine = stubLine.replace("${BASE}", messageFile.getBaseName());
|
outputWriter.println(stubLine);
|
}
|
}
|
}
|
catch (final Exception e)
|
{
|
// Don't leave a malformed file laying around. Delete it so it will be
|
// forced to be regenerated.
|
if (outputFile.exists())
|
{
|
outputFile.deleteOnExit();
|
}
|
throw new MojoExecutionException(
|
"An IO error occurred while generating the message file: " + e);
|
}
|
finally
|
{
|
if (stubReader != null)
|
{
|
try
|
{
|
stubReader.close();
|
}
|
catch (final Exception e)
|
{
|
// Ignore.
|
}
|
}
|
|
if (outputWriter != null)
|
{
|
try
|
{
|
outputWriter.close();
|
}
|
catch (final Exception e)
|
{
|
// Ignore.
|
}
|
}
|
}
|
|
}
|
|
|
|
private String quote(final String s)
|
{
|
return new StringBuilder().append("\"").append(s).append("\"").toString();
|
}
|
}
|
