You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by rf...@apache.org on 2017/08/12 13:15:49 UTC
svn commit: r1804865 [1/2] - in /maven/plugins/trunk/maven-javadoc-plugin:
./ src/main/java/org/apache/maven/plugins/javadoc/
src/test/java/org/apache/maven/plugins/javadoc/
Author: rfscholte
Date: Sat Aug 12 13:15:49 2017
New Revision: 1804865
URL: http://svn.apache.org/viewvc?rev=1804865&view=rev
Log:
[MJAVADOC-493] Upgrade to QDox 2
Modified:
maven/plugins/trunk/maven-javadoc-plugin/pom.xml
maven/plugins/trunk/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/AbstractFixJavadocMojo.java
maven/plugins/trunk/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/AbstractFixJavadocMojoTest.java
maven/plugins/trunk/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/FixJavadocMojoTest.java
Modified: maven/plugins/trunk/maven-javadoc-plugin/pom.xml
URL: http://svn.apache.org/viewvc/maven/plugins/trunk/maven-javadoc-plugin/pom.xml?rev=1804865&r1=1804864&r2=1804865&view=diff
==============================================================================
--- maven/plugins/trunk/maven-javadoc-plugin/pom.xml (original)
+++ maven/plugins/trunk/maven-javadoc-plugin/pom.xml Sat Aug 12 13:15:49 2017
@@ -216,7 +216,7 @@ under the License.
<dependency>
<groupId>com.thoughtworks.qdox</groupId>
<artifactId>qdox</artifactId>
- <version>1.12.1</version>
+ <version>2.0-M7</version>
</dependency>
<!-- Plexus -->
Modified: maven/plugins/trunk/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/AbstractFixJavadocMojo.java
URL: http://svn.apache.org/viewvc/maven/plugins/trunk/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/AbstractFixJavadocMojo.java?rev=1804865&r1=1804864&r2=1804865&view=diff
==============================================================================
--- maven/plugins/trunk/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/AbstractFixJavadocMojo.java (original)
+++ maven/plugins/trunk/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/AbstractFixJavadocMojo.java Sat Aug 12 13:15:49 2017
@@ -19,18 +19,25 @@ package org.apache.maven.plugins.javadoc
* under the License.
*/
-import com.thoughtworks.qdox.JavaDocBuilder;
-import com.thoughtworks.qdox.model.AbstractInheritableJavaEntity;
-import com.thoughtworks.qdox.model.AbstractJavaEntity;
-import com.thoughtworks.qdox.model.Annotation;
+import com.thoughtworks.qdox.JavaProjectBuilder;
+import com.thoughtworks.qdox.library.ClassLibraryBuilder;
+import com.thoughtworks.qdox.library.OrderedClassLibraryBuilder;
import com.thoughtworks.qdox.model.DocletTag;
+import com.thoughtworks.qdox.model.JavaAnnotatedElement;
+import com.thoughtworks.qdox.model.JavaAnnotation;
import com.thoughtworks.qdox.model.JavaClass;
+import com.thoughtworks.qdox.model.JavaConstructor;
+import com.thoughtworks.qdox.model.JavaExecutable;
import com.thoughtworks.qdox.model.JavaField;
+import com.thoughtworks.qdox.model.JavaGenericDeclaration;
+import com.thoughtworks.qdox.model.JavaMember;
import com.thoughtworks.qdox.model.JavaMethod;
import com.thoughtworks.qdox.model.JavaParameter;
-import com.thoughtworks.qdox.model.Type;
-import com.thoughtworks.qdox.model.TypeVariable;
+import com.thoughtworks.qdox.model.JavaType;
+import com.thoughtworks.qdox.model.JavaTypeVariable;
import com.thoughtworks.qdox.parser.ParseException;
+import com.thoughtworks.qdox.type.TypeResolver;
+
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.ClassUtils;
import org.apache.maven.artifact.Artifact;
@@ -64,6 +71,7 @@ import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
@@ -451,7 +459,7 @@ public abstract class AbstractFixJavadoc
// run qdox and process
try
{
- JavaClass[] javaClasses = getQdoxClasses();
+ Collection<JavaClass> javaClasses = getQdoxClasses();
if ( javaClasses != null )
{
@@ -506,13 +514,12 @@ public abstract class AbstractFixJavadoc
}
/**
- * @param javaMethod not null
+ * @param javaExecutable not null
* @return the fully qualify name of javaMethod with signature
*/
- protected static String getJavaMethodAsString( JavaMethod javaMethod )
+ protected static String getJavaMethodAsString( JavaExecutable javaExecutable )
{
-
- return javaMethod.getParentClass().getFullyQualifiedName() + "#" + javaMethod.getCallSignature();
+ return javaExecutable.getDeclaringClass().getFullyQualifiedName() + "#" + javaExecutable.getCallSignature();
}
// ----------------------------------------------------------------------
@@ -870,7 +877,7 @@ public abstract class AbstractFixJavadoc
* @throws IOException if any
* @throws MojoExecutionException if any
*/
- private JavaClass[] getQdoxClasses()
+ private Collection<JavaClass> getQdoxClasses()
throws IOException, MojoExecutionException
{
if ( "pom".equalsIgnoreCase( project.getPackaging() ) )
@@ -896,8 +903,10 @@ public abstract class AbstractFixJavadoc
}
}
- JavaDocBuilder builder = new JavaDocBuilder();
- builder.getClassLibrary().addClassLoader( getProjectClassLoader() );
+ ClassLibraryBuilder classLibraryBuilder = new OrderedClassLibraryBuilder();
+ classLibraryBuilder.appendClassLoader( getProjectClassLoader() );
+
+ JavaProjectBuilder builder = new JavaProjectBuilder( classLibraryBuilder );
builder.setEncoding( encoding );
for ( File f : javaFiles )
{
@@ -1001,23 +1010,20 @@ public abstract class AbstractFixJavadoc
// fixing classes
if ( javaClass.getComment() == null && javaClass.getAnnotations() != null
- && javaClass.getAnnotations().length != 0 )
+ && !javaClass.getAnnotations().isEmpty() )
{
- if ( lineNumber == javaClass.getAnnotations()[0].getLineNumber() )
+ if ( lineNumber == javaClass.getAnnotations().get( 0 ).getLineNumber() )
{
changeDetected |= fixClassComment( stringWriter, originalContent, javaClass, indent );
takeCareSingleComment( stringWriter, originalContent, javaClass );
}
}
- else
+ else if ( lineNumber == javaClass.getLineNumber() )
{
- if ( lineNumber == javaClass.getLineNumber() )
- {
- changeDetected |= fixClassComment( stringWriter, originalContent, javaClass, indent );
+ changeDetected |= fixClassComment( stringWriter, originalContent, javaClass, indent );
- takeCareSingleComment( stringWriter, originalContent, javaClass );
- }
+ takeCareSingleComment( stringWriter, originalContent, javaClass );
}
// fixing fields
@@ -1031,11 +1037,11 @@ public abstract class AbstractFixJavadoc
}
}
}
-
+
// fixing methods
- if ( javaClass.getMethods() != null )
+ if ( javaClass.getConstructors() != null )
{
- for ( JavaMethod method : javaClass.getMethods() )
+ for ( JavaConstructor method : javaClass.getConstructors() )
{
if ( lineNumber == method.getLineNumber() )
{
@@ -1045,6 +1051,28 @@ public abstract class AbstractFixJavadoc
}
}
}
+
+
+ // fixing methods
+ for ( JavaMethod method : javaClass.getMethods() )
+ {
+ int methodLineNumber;
+ if ( method.getComment() == null && !method.getAnnotations().isEmpty() )
+ {
+ methodLineNumber = method.getAnnotations().get( 0 ).getLineNumber();
+ }
+ else
+ {
+ methodLineNumber = method.getLineNumber();
+ }
+
+ if ( lineNumber == methodLineNumber )
+ {
+ changeDetected |= fixMethodComment( stringWriter, originalContent, method, indent );
+
+ takeCareSingleComment( stringWriter, originalContent, method );
+ }
+ }
stringWriter.write( line );
stringWriter.write( EOL );
@@ -1117,7 +1145,7 @@ public abstract class AbstractFixJavadoc
* @see #extractOriginalJavadoc(String, AbstractJavaEntity)
*/
private void takeCareSingleComment( final StringWriter stringWriter, final String originalContent,
- final AbstractInheritableJavaEntity entity )
+ final JavaAnnotatedElement entity )
throws IOException
{
if ( entity.getComment() == null )
@@ -1181,23 +1209,21 @@ public abstract class AbstractFixJavadoc
* @param modifiers list of modifiers (public, private, protected, package)
* @return <code>true</code> if modifier is align with <code>level</code>.
*/
- private boolean isInLevel( String[] modifiers )
+ private boolean isInLevel( List<String> modifiers )
{
- List<String> modifiersAsList = Arrays.asList( modifiers );
-
if ( LEVEL_PUBLIC.equalsIgnoreCase( level.trim() ) )
{
- return modifiersAsList.contains( LEVEL_PUBLIC );
+ return modifiers.contains( LEVEL_PUBLIC );
}
if ( LEVEL_PROTECTED.equalsIgnoreCase( level.trim() ) )
{
- return ( modifiersAsList.contains( LEVEL_PUBLIC ) || modifiersAsList.contains( LEVEL_PROTECTED ) );
+ return ( modifiers.contains( LEVEL_PUBLIC ) || modifiers.contains( LEVEL_PROTECTED ) );
}
if ( LEVEL_PACKAGE.equalsIgnoreCase( level.trim() ) )
{
- return !modifiersAsList.contains( LEVEL_PRIVATE );
+ return !modifiers.contains( LEVEL_PRIVATE );
}
// should be private (shows all classes and members)
@@ -1341,7 +1367,7 @@ public abstract class AbstractFixJavadoc
if ( StringUtils.isNotEmpty( field.getInitializationExpression() ) )
{
- String qualifiedName = field.getType().getJavaClass().getFullyQualifiedName();
+ String qualifiedName = field.getType().getFullyQualifiedName();
if ( qualifiedName.equals( Byte.TYPE.toString() ) || qualifiedName.equals( Short.TYPE.toString() )
|| qualifiedName.equals( Integer.TYPE.toString() ) || qualifiedName.equals( Long.TYPE.toString() )
@@ -1402,14 +1428,14 @@ public abstract class AbstractFixJavadoc
*
* @param stringWriter not null
* @param originalContent not null
- * @param javaMethod not null
+ * @param javaExecutable not null
* @param indent not null
* @return {@code true} if comment was updated, otherwise {@code false}
* @throws MojoExecutionException if any
* @throws IOException if any
*/
private boolean fixMethodComment( final StringWriter stringWriter, final String originalContent,
- final JavaMethod javaMethod, final String indent )
+ final JavaExecutable javaExecutable, final String indent )
throws MojoExecutionException, IOException
{
if ( !fixMethodComment )
@@ -1417,20 +1443,20 @@ public abstract class AbstractFixJavadoc
return false;
}
- if ( !javaMethod.getParentClass().isInterface() && !isInLevel( javaMethod.getModifiers() ) )
+ if ( !javaExecutable.getDeclaringClass().isInterface() && !isInLevel( javaExecutable.getModifiers() ) )
{
return false;
}
// add
- if ( javaMethod.getComment() == null )
+ if ( javaExecutable.getComment() == null )
{
- addDefaultMethodComment( stringWriter, javaMethod, indent );
+ addDefaultMethodComment( stringWriter, javaExecutable, indent );
return true;
}
// update
- return updateEntityComment( stringWriter, originalContent, javaMethod, indent );
+ return updateEntityComment( stringWriter, originalContent, javaExecutable, indent );
}
/**
@@ -1465,20 +1491,20 @@ public abstract class AbstractFixJavadoc
* </code>
*
* @param buffer not null
- * @param javaMethod not null
+ * @param javaExecutable not null
* @param indent not null
* @throws MojoExecutionException if any
* @see #getDefaultMethodJavadocComment(JavaMethod)
* @see #appendDefaultSinceTag(StringBuilder, String)
*/
- private void addDefaultMethodComment( final StringWriter stringWriter, final JavaMethod javaMethod,
+ private void addDefaultMethodComment( final StringWriter stringWriter, final JavaExecutable javaExecutable,
final String indent )
throws MojoExecutionException
{
StringBuilder sb = new StringBuilder();
// special case
- if ( isInherited( javaMethod ) )
+ if ( isInherited( javaExecutable ) )
{
sb.append( indent ).append( INHERITED_JAVADOC );
sb.append( EOL );
@@ -1490,46 +1516,45 @@ public abstract class AbstractFixJavadoc
sb.append( indent ).append( START_JAVADOC );
sb.append( EOL );
sb.append( indent ).append( SEPARATOR_JAVADOC );
- sb.append( getDefaultMethodJavadocComment( javaMethod ) );
+ sb.append( getDefaultMethodJavadocComment( javaExecutable ) );
sb.append( EOL );
boolean separatorAdded = false;
if ( fixTag( PARAM_TAG ) )
{
- if ( javaMethod.getParameters() != null )
+ if ( javaExecutable.getParameters() != null )
{
- for ( int i = 0; i < javaMethod.getParameters().length; i++ )
+ for ( JavaParameter javaParameter : javaExecutable.getParameters() )
{
- JavaParameter javaParameter = javaMethod.getParameters()[i];
-
separatorAdded = appendDefaultParamTag( sb, indent, separatorAdded, javaParameter );
}
}
// is generic?
- if ( javaMethod.getTypeParameters() != null )
+ if ( javaExecutable.getTypeParameters() != null )
{
- for ( int i = 0; i < javaMethod.getTypeParameters().length; i++ )
+ for ( JavaTypeVariable<JavaGenericDeclaration> typeParam : javaExecutable.getTypeParameters() )
{
- TypeVariable typeParam = javaMethod.getTypeParameters()[i];
-
separatorAdded = appendDefaultParamTag( sb, indent, separatorAdded, typeParam );
}
}
}
- if ( fixTag( RETURN_TAG ) && javaMethod.getReturns() != null && !javaMethod.getReturns().isVoid() )
+ if ( javaExecutable instanceof JavaMethod )
{
- separatorAdded = appendDefaultReturnTag( sb, indent, separatorAdded, javaMethod );
+ JavaMethod javaMethod = (JavaMethod) javaExecutable;
+ if ( fixTag( RETURN_TAG ) && javaMethod.getReturns() != null && !javaMethod.getReturns().isVoid() )
+ {
+ separatorAdded = appendDefaultReturnTag( sb, indent, separatorAdded, javaMethod );
+ }
+
}
- if ( fixTag( THROWS_TAG ) && javaMethod.getExceptions() != null && javaMethod.getExceptions().length > 0 )
+ if ( fixTag( THROWS_TAG ) && javaExecutable.getExceptions() != null )
{
- for ( int i = 0; i < javaMethod.getExceptions().length; i++ )
+ for ( JavaType exception : javaExecutable.getExceptions() )
{
- Type exception = javaMethod.getExceptions()[i];
-
separatorAdded = appendDefaultThrowsTag( sb, indent, separatorAdded, exception );
}
}
- if ( fixTag( SINCE_TAG ) && isNewMethodFromLastRevision( javaMethod ) )
+ if ( fixTag( SINCE_TAG ) && isNewMethodFromLastRevision( javaExecutable ) )
{
separatorAdded = appendDefaultSinceTag( sb, indent, separatorAdded );
}
@@ -1551,7 +1576,7 @@ public abstract class AbstractFixJavadoc
* @throws IOException if any
*/
private boolean updateEntityComment( final StringWriter stringWriter, final String originalContent,
- final AbstractInheritableJavaEntity entity, final String indent )
+ final JavaAnnotatedElement entity, final String indent )
throws MojoExecutionException, IOException
{
boolean changeDetected = false;
@@ -1597,26 +1622,26 @@ public abstract class AbstractFixJavadoc
* @throws IOException if any
*/
private void updateJavadocComment( final StringWriter stringWriter, final String originalContent,
- final AbstractInheritableJavaEntity entity, final String indent )
+ final JavaAnnotatedElement entity, final String indent )
throws MojoExecutionException, IOException
{
- if ( entity.getComment() == null && ( entity.getTags() == null || entity.getTags().length == 0 ) )
+ if ( entity.getComment() == null && ( entity.getTags() == null || entity.getTags().isEmpty() ) )
{
return;
}
- boolean isJavaMethod = false;
- if ( entity instanceof JavaMethod )
+ boolean isJavaExecutable = false;
+ if ( entity instanceof JavaExecutable )
{
- isJavaMethod = true;
+ isJavaExecutable = true;
}
StringBuilder sb = new StringBuilder();
// special case for inherited method
- if ( isJavaMethod )
+ if ( isJavaExecutable )
{
- JavaMethod javaMethod = (JavaMethod) entity;
+ JavaExecutable javaMethod = (JavaExecutable) entity;
if ( isInherited( javaMethod ) )
{
@@ -1633,7 +1658,7 @@ public abstract class AbstractFixJavadoc
// case: /** {@inheritDoc} */ or no tags
if ( hasInheritedTag( javadoc ) && ( javaMethod.getTags() == null
- || javaMethod.getTags().length == 0 ) )
+ || javaMethod.getTags().isEmpty() ) )
{
sb.append( indent ).append( INHERITED_JAVADOC );
sb.append( EOL );
@@ -1664,10 +1689,8 @@ public abstract class AbstractFixJavadoc
sb.append( EOL );
if ( javaMethod.getTags() != null )
{
- for ( int i = 0; i < javaMethod.getTags().length; i++ )
+ for ( DocletTag docletTag : javaMethod.getTags() )
{
- DocletTag docletTag = javaMethod.getTags()[i];
-
// Voluntary ignore these tags
if ( JavadocUtil.equals( docletTag.getName(), PARAM_TAG, RETURN_TAG, THROWS_TAG ) )
{
@@ -1708,17 +1731,17 @@ public abstract class AbstractFixJavadoc
}
else
{
- addDefaultJavadocComment( sb, entity, indent, isJavaMethod );
+ addDefaultJavadocComment( sb, entity, indent, isJavaExecutable );
}
// tags
- if ( entity.getTags() != null && entity.getTags().length > 0 )
+ if ( entity.getTags() != null && !entity.getTags().isEmpty() )
{
- updateJavadocTags( sb, originalContent, entity, indent, isJavaMethod );
+ updateJavadocTags( sb, originalContent, entity, indent, isJavaExecutable );
}
else
{
- addDefaultJavadocTags( sb, entity, indent, isJavaMethod );
+ addDefaultJavadocTags( sb, entity, indent, isJavaExecutable );
}
sb = new StringBuilder( removeLastEmptyJavadocLines( sb.toString() ) ).append( EOL );
@@ -1737,7 +1760,7 @@ public abstract class AbstractFixJavadoc
* @throws IOException if any
*/
private void updateJavadocComment( final StringBuilder sb, final String originalContent,
- final AbstractInheritableJavaEntity entity, final String indent )
+ final JavaAnnotatedElement entity, final String indent )
throws IOException
{
String comment = getJavadocComment( originalContent, entity );
@@ -1767,7 +1790,7 @@ public abstract class AbstractFixJavadoc
}
}
- private static String replaceLinkTags( String comment, AbstractInheritableJavaEntity entity )
+ static String replaceLinkTags( String comment, JavaAnnotatedElement entity )
{
StringBuilder resolvedComment = new StringBuilder();
// scan comment for {@link someClassName} and try to resolve this
@@ -1796,11 +1819,21 @@ public abstract class AbstractFixJavadoc
String typeName;
if ( entity instanceof JavaClass )
{
- typeName = ( (JavaClass) entity ).resolveType( name.trim() );
+ JavaClass clazz = (JavaClass) entity;
+ typeName =
+ TypeResolver.byClassName( clazz.getBinaryName(), clazz.getJavaClassLibrary(),
+ clazz.getSource().getImports() ).resolveType( name.trim() );
+ }
+ else if ( entity instanceof JavaMember )
+ {
+ JavaClass clazz = ( (JavaMember) entity ).getDeclaringClass();
+ typeName =
+ TypeResolver.byClassName( clazz.getBinaryName(), clazz.getJavaClassLibrary(),
+ clazz.getSource().getImports() ).resolveType( name.trim() );
}
else
{
- typeName = entity.getParentClass().resolveType( name.trim() );
+ typeName = null;
}
if ( typeName == null )
@@ -1835,15 +1868,15 @@ public abstract class AbstractFixJavadoc
* @param sb not null
* @param entity not null
* @param indent not null
- * @param isJavaMethod
+ * @param isJavaExecutable
*/
- private void addDefaultJavadocComment( final StringBuilder sb, final AbstractInheritableJavaEntity entity,
- final String indent, final boolean isJavaMethod )
+ private void addDefaultJavadocComment( final StringBuilder sb, final JavaAnnotatedElement entity,
+ final String indent, final boolean isJavaExecutable )
{
sb.append( indent ).append( SEPARATOR_JAVADOC );
- if ( isJavaMethod )
+ if ( isJavaExecutable )
{
- sb.append( getDefaultMethodJavadocComment( (JavaMethod) entity ) );
+ sb.append( getDefaultMethodJavadocComment( (JavaExecutable) entity ) );
}
else
{
@@ -1857,25 +1890,25 @@ public abstract class AbstractFixJavadoc
* @param originalContent not null
* @param entity not null
* @param indent not null
- * @param isJavaMethod
+ * @param isJavaExecutable
* @throws IOException if any
* @throws MojoExecutionException if any
*/
private void updateJavadocTags( final StringBuilder sb, final String originalContent,
- final AbstractInheritableJavaEntity entity, final String indent,
- final boolean isJavaMethod )
+ final JavaAnnotatedElement entity, final String indent,
+ final boolean isJavaExecutable )
throws IOException, MojoExecutionException
{
appendSeparator( sb, indent );
// parse tags
- JavaEntityTags javaEntityTags = parseJavadocTags( originalContent, entity, indent, isJavaMethod );
+ JavaEntityTags javaEntityTags = parseJavadocTags( originalContent, entity, indent, isJavaExecutable );
// update and write tags
- updateJavadocTags( sb, entity, isJavaMethod, javaEntityTags );
+ updateJavadocTags( sb, entity, isJavaExecutable, javaEntityTags );
// add missing tags...
- addMissingJavadocTags( sb, entity, indent, isJavaMethod, javaEntityTags );
+ addMissingJavadocTags( sb, entity, indent, isJavaExecutable, javaEntityTags );
}
/**
@@ -1888,15 +1921,13 @@ public abstract class AbstractFixJavadoc
* @return an instance of {@link JavaEntityTags}
* @throws IOException if any
*/
- JavaEntityTags parseJavadocTags( final String originalContent, final AbstractInheritableJavaEntity entity,
+ JavaEntityTags parseJavadocTags( final String originalContent, final JavaAnnotatedElement entity,
final String indent, final boolean isJavaMethod )
throws IOException
{
JavaEntityTags javaEntityTags = new JavaEntityTags( entity, isJavaMethod );
- for ( int i = 0; i < entity.getTags().length; i++ )
+ for ( DocletTag docletTag : entity.getTags() )
{
- DocletTag docletTag = entity.getTags()[i];
-
String originalJavadocTag = getJavadocComment( originalContent, entity, docletTag );
originalJavadocTag = removeLastEmptyJavadocLines( originalJavadocTag );
originalJavadocTag = alignIndentationJavadocLines( originalJavadocTag, indent );
@@ -1905,14 +1936,13 @@ public abstract class AbstractFixJavadoc
if ( isJavaMethod )
{
- String[] params = docletTag.getParameters();
- if ( params.length < 1 )
+ List<String> params = docletTag.getParameters();
+ if ( params.size() < 1 )
{
continue;
}
- params = fixQdox173( params );
- String paramName = params[0];
+ String paramName = params.get( 0 );
if ( docletTag.getName().equals( PARAM_TAG ) )
{
javaEntityTags.putJavadocParamTag( paramName, originalJavadocTag );
@@ -1944,37 +1974,35 @@ public abstract class AbstractFixJavadoc
*
* @param sb not null
* @param entity not null
- * @param isJavaMethod
+ * @param isJavaExecutable
* @param javaEntityTags not null
*/
- private void updateJavadocTags( final StringBuilder sb, final AbstractInheritableJavaEntity entity,
- final boolean isJavaMethod, final JavaEntityTags javaEntityTags )
+ private void updateJavadocTags( final StringBuilder sb, final JavaAnnotatedElement entity,
+ final boolean isJavaExecutable, final JavaEntityTags javaEntityTags )
{
- for ( int i = 0; i < entity.getTags().length; i++ )
+ for ( DocletTag docletTag : entity.getTags() )
{
- DocletTag docletTag = entity.getTags()[i];
-
- if ( isJavaMethod )
+ if ( isJavaExecutable )
{
- JavaMethod javaMethod = (JavaMethod) entity;
+ JavaExecutable javaExecutable = (JavaExecutable) entity;
- String[] params = docletTag.getParameters();
- if ( params.length < 1 )
+ List<String> params = docletTag.getParameters();
+ if ( params.size() < 1 )
{
continue;
}
if ( docletTag.getName().equals( PARAM_TAG ) )
{
- writeParamTag( sb, javaMethod, javaEntityTags, params );
+ writeParamTag( sb, javaExecutable, javaEntityTags, params );
}
- else if ( docletTag.getName().equals( RETURN_TAG ) )
+ else if ( docletTag.getName().equals( RETURN_TAG ) && javaExecutable instanceof JavaMethod )
{
- writeReturnTag( sb, javaMethod, javaEntityTags );
+ writeReturnTag( sb, (JavaMethod) javaExecutable, javaEntityTags );
}
else if ( docletTag.getName().equals( THROWS_TAG ) )
{
- writeThrowsTag( sb, javaMethod, javaEntityTags, params );
+ writeThrowsTag( sb, javaExecutable, javaEntityTags, params );
}
else
{
@@ -2018,12 +2046,10 @@ public abstract class AbstractFixJavadoc
}
}
- private void writeParamTag( final StringBuilder sb, final JavaMethod javaMethod,
- final JavaEntityTags javaEntityTags, String[] params )
+ private void writeParamTag( final StringBuilder sb, final JavaExecutable javaExecutable,
+ final JavaEntityTags javaEntityTags, List<String> params )
{
- params = fixQdox173( params );
-
- String paramName = params[0];
+ String paramName = params.get( 0 );
if ( !fixTag( PARAM_TAG ) )
{
@@ -2037,12 +2063,12 @@ public abstract class AbstractFixJavadoc
}
boolean found = false;
- JavaParameter javaParam = javaMethod.getParameterByName( paramName );
+ JavaParameter javaParam = javaExecutable.getParameterByName( paramName );
if ( javaParam == null )
{
// is generic?
- TypeVariable[] typeParams = javaMethod.getTypeParameters();
- for ( TypeVariable typeParam : typeParams )
+ List<JavaTypeVariable<JavaGenericDeclaration>> typeParams = javaExecutable.getTypeParameters();
+ for ( JavaTypeVariable<JavaGenericDeclaration> typeParam : typeParams )
{
if ( typeParam.getGenericValue().equals( paramName ) )
{
@@ -2060,7 +2086,7 @@ public abstract class AbstractFixJavadoc
if ( getLog().isWarnEnabled() )
{
getLog().warn(
- "Fixed unknown param '" + paramName + "' defined in " + getJavaMethodAsString( javaMethod ) );
+ "Fixed unknown param '" + paramName + "' defined in " + getJavaMethodAsString( javaExecutable ) );
}
if ( sb.toString().endsWith( EOL ) )
@@ -2078,7 +2104,7 @@ public abstract class AbstractFixJavadoc
if ( StringUtils.removeDuplicateWhitespace( originalJavadocTag ).trim().endsWith( s ) )
{
sb.append( " " );
- sb.append( getDefaultJavadocForType( javaParam.getType() ) );
+ sb.append( getDefaultJavadocForType( javaParam.getJavaClass() ) );
}
}
}
@@ -2112,10 +2138,10 @@ public abstract class AbstractFixJavadoc
}
}
- void writeThrowsTag( final StringBuilder sb, final JavaMethod javaMethod,
- final JavaEntityTags javaEntityTags, final String[] params )
+ void writeThrowsTag( final StringBuilder sb, final JavaExecutable javaExecutable,
+ final JavaEntityTags javaEntityTags, final List<String> params )
{
- String exceptionClassName = params[0];
+ String exceptionClassName = params.get( 0 );
String originalJavadocTag = javaEntityTags.getJavadocThrowsTag( exceptionClassName );
if ( originalJavadocTag == null )
@@ -2130,16 +2156,14 @@ public abstract class AbstractFixJavadoc
return;
}
- if ( javaMethod.getExceptions() != null )
+ if ( javaExecutable.getExceptions() != null )
{
- for ( int j = 0; j < javaMethod.getExceptions().length; j++ )
+ for ( JavaType exception : javaExecutable.getExceptions() )
{
- Type exception = javaMethod.getExceptions()[j];
-
if ( exception.getValue().endsWith( exceptionClassName ) )
{
- originalJavadocTag =
- StringUtils.replace( originalJavadocTag, exceptionClassName, exception.getValue() );
+ originalJavadocTag = StringUtils.replace( originalJavadocTag, exceptionClassName,
+ exception.getFullyQualifiedName() );
if ( StringUtils.removeDuplicateWhitespace( originalJavadocTag ).trim().endsWith(
"@" + THROWS_TAG + " " + exception.getValue() ) )
{
@@ -2156,7 +2180,7 @@ public abstract class AbstractFixJavadoc
}
}
- Class<?> clazz = getClass( javaMethod.getParentClass(), exceptionClassName );
+ Class<?> clazz = getClass( javaExecutable.getDeclaringClass(), exceptionClassName );
if ( clazz != null )
{
@@ -2170,7 +2194,7 @@ public abstract class AbstractFixJavadoc
else if ( ClassUtils.isAssignable( clazz, Throwable.class ) )
{
getLog().debug( "Removing '" + originalJavadocTag + "'; Throwable not specified by "
- + getJavaMethodAsString( javaMethod ) + " and it is not a RuntimeException." );
+ + getJavaMethodAsString( javaExecutable ) + " and it is not a RuntimeException." );
}
else
{
@@ -2180,16 +2204,16 @@ public abstract class AbstractFixJavadoc
else if ( removeUnknownThrows )
{
getLog().warn( "Ignoring unknown throws '" + exceptionClassName + "' defined on "
- + getJavaMethodAsString( javaMethod ) );
+ + getJavaMethodAsString( javaExecutable ) );
}
else
{
getLog().warn( "Found unknown throws '" + exceptionClassName + "' defined on "
- + getJavaMethodAsString( javaMethod ) );
+ + getJavaMethodAsString( javaExecutable ) );
sb.append( originalJavadocTag );
- if ( params.length == 1 )
+ if ( params.size() == 1 )
{
sb.append( " if any." );
}
@@ -2204,27 +2228,25 @@ public abstract class AbstractFixJavadoc
* @param sb not null
* @param entity not null
* @param indent not null
- * @param isJavaMethod
+ * @param isJavaExecutable
* @param javaEntityTags not null
* @throws MojoExecutionException if any
*/
- private void addMissingJavadocTags( final StringBuilder sb, final AbstractInheritableJavaEntity entity,
- final String indent, final boolean isJavaMethod,
+ private void addMissingJavadocTags( final StringBuilder sb, final JavaAnnotatedElement entity,
+ final String indent, final boolean isJavaExecutable,
final JavaEntityTags javaEntityTags )
throws MojoExecutionException
{
- if ( isJavaMethod )
+ if ( isJavaExecutable )
{
- JavaMethod javaMethod = (JavaMethod) entity;
+ JavaExecutable javaExecutable = (JavaExecutable) entity;
if ( fixTag( PARAM_TAG ) )
{
- if ( javaMethod.getParameters() != null )
+ if ( javaExecutable.getParameters() != null )
{
- for ( int i = 0; i < javaMethod.getParameters().length; i++ )
+ for ( JavaParameter javaParameter : javaExecutable.getParameters() )
{
- JavaParameter javaParameter = javaMethod.getParameters()[i];
-
if ( javaEntityTags.getJavadocParamTag( javaParameter.getName(), true ) == null )
{
appendDefaultParamTag( sb, indent, javaParameter );
@@ -2232,12 +2254,10 @@ public abstract class AbstractFixJavadoc
}
}
// is generic?
- if ( javaMethod.getTypeParameters() != null )
+ if ( javaExecutable.getTypeParameters() != null )
{
- for ( int i = 0; i < javaMethod.getTypeParameters().length; i++ )
+ for ( JavaTypeVariable<JavaGenericDeclaration> typeParam : javaExecutable.getTypeParameters() )
{
- TypeVariable typeParam = javaMethod.getTypeParameters()[i];
-
if ( javaEntityTags.getJavadocParamTag( "<" + typeParam.getName() + ">", true ) == null )
{
appendDefaultParamTag( sb, indent, typeParam );
@@ -2246,18 +2266,20 @@ public abstract class AbstractFixJavadoc
}
}
- if ( fixTag( RETURN_TAG ) && StringUtils.isEmpty( javaEntityTags.getJavadocReturnTag() )
- && javaMethod.getReturns() != null && !javaMethod.getReturns().isVoid() )
+ if ( javaExecutable instanceof JavaMethod )
{
- appendDefaultReturnTag( sb, indent, javaMethod );
+ JavaMethod javaMethod = (JavaMethod) javaExecutable;
+ if ( fixTag( RETURN_TAG ) && StringUtils.isEmpty( javaEntityTags.getJavadocReturnTag() )
+ && javaMethod.getReturns() != null && !javaMethod.getReturns().isVoid() )
+ {
+ appendDefaultReturnTag( sb, indent, javaMethod );
+ }
}
- if ( fixTag( THROWS_TAG ) && javaMethod.getExceptions() != null )
+ if ( fixTag( THROWS_TAG ) && javaExecutable.getExceptions() != null )
{
- for ( int i = 0; i < javaMethod.getExceptions().length; i++ )
+ for ( JavaType exception : javaExecutable.getExceptions() )
{
- Type exception = javaMethod.getExceptions()[i];
-
if ( javaEntityTags.getJavadocThrowsTag( exception.getValue(), true ) == null )
{
appendDefaultThrowsTag( sb, indent, exception );
@@ -2276,9 +2298,10 @@ public abstract class AbstractFixJavadoc
appendDefaultVersionTag( sb, indent );
}
}
+
if ( fixTag( SINCE_TAG ) && !javaEntityTags.getNamesTags().contains( SINCE_TAG ) )
{
- if ( !isJavaMethod )
+ if ( !isJavaExecutable )
{
if ( !ignoreClirr )
{
@@ -2297,14 +2320,20 @@ public abstract class AbstractFixJavadoc
{
if ( !ignoreClirr )
{
- if ( isNewMethodFromLastRevision( (JavaMethod) entity ) )
+ if ( isNewMethodFromLastRevision( (JavaExecutable) entity ) )
{
appendDefaultSinceTag( sb, indent );
}
}
- else
+ else if ( sinceClasses != null )
{
- if ( sinceClasses != null && !sinceClassesContains( entity.getParentClass() ) )
+ if ( entity instanceof JavaMember
+ && !sinceClassesContains( ( (JavaMember) entity ).getDeclaringClass() ) )
+ {
+ appendDefaultSinceTag( sb, indent );
+ }
+ else if ( entity instanceof JavaClass
+ && !sinceClassesContains( ( (JavaClass) entity ).getDeclaringClass() ) )
{
appendDefaultSinceTag( sb, indent );
}
@@ -2317,42 +2346,39 @@ public abstract class AbstractFixJavadoc
* @param sb not null
* @param entity not null
* @param indent not null
- * @param isJavaMethod
+ * @param isJavaExecutable
* @throws MojoExecutionException if any
*/
- private void addDefaultJavadocTags( final StringBuilder sb, final AbstractInheritableJavaEntity entity,
- final String indent, final boolean isJavaMethod )
+ private void addDefaultJavadocTags( final StringBuilder sb, final JavaAnnotatedElement entity,
+ final String indent, final boolean isJavaExecutable )
throws MojoExecutionException
{
boolean separatorAdded = false;
- if ( isJavaMethod )
+ if ( isJavaExecutable )
{
- JavaMethod javaMethod = (JavaMethod) entity;
+ JavaExecutable javaExecutable = (JavaExecutable) entity;
- if ( fixTag( PARAM_TAG ) && javaMethod.getParameters() != null )
+ if ( fixTag( PARAM_TAG ) && javaExecutable.getParameters() != null )
{
- for ( int i = 0; i < javaMethod.getParameters().length; i++ )
+ for ( JavaParameter javaParameter : javaExecutable.getParameters() )
{
- JavaParameter javaParameter = javaMethod.getParameters()[i];
-
separatorAdded = appendDefaultParamTag( sb, indent, separatorAdded, javaParameter );
}
}
- if ( fixTag( RETURN_TAG ) )
+ if ( javaExecutable instanceof JavaMethod && fixTag( RETURN_TAG ) )
{
+ JavaMethod javaMethod = (JavaMethod) javaExecutable;
if ( javaMethod.getReturns() != null && !javaMethod.getReturns().isVoid() )
{
separatorAdded = appendDefaultReturnTag( sb, indent, separatorAdded, javaMethod );
}
}
- if ( fixTag( THROWS_TAG ) && javaMethod.getExceptions() != null )
+ if ( fixTag( THROWS_TAG ) && javaExecutable.getExceptions() != null )
{
- for ( int i = 0; i < javaMethod.getExceptions().length; i++ )
+ for ( JavaType exception : javaExecutable.getExceptions() )
{
- Type exception = javaMethod.getExceptions()[i];
-
separatorAdded = appendDefaultThrowsTag( sb, indent, separatorAdded, exception );
}
}
@@ -2366,7 +2392,7 @@ public abstract class AbstractFixJavadoc
if ( fixTag( SINCE_TAG ) )
{
- if ( !isJavaMethod )
+ if ( !isJavaExecutable )
{
JavaClass javaClass = (JavaClass) entity;
@@ -2386,18 +2412,18 @@ public abstract class AbstractFixJavadoc
}
else
{
- JavaMethod javaMethod = (JavaMethod) entity;
+ JavaExecutable javaExecutable = (JavaExecutable) entity;
if ( !ignoreClirr )
{
- if ( isNewMethodFromLastRevision( javaMethod ) )
+ if ( isNewMethodFromLastRevision( javaExecutable ) )
{
separatorAdded = appendDefaultSinceTag( sb, indent, separatorAdded );
}
}
else
{
- if ( sinceClasses != null && !sinceClassesContains( javaMethod.getParentClass() ) )
+ if ( sinceClasses != null && !sinceClassesContains( javaExecutable.getDeclaringClass() ) )
{
separatorAdded = appendDefaultSinceTag( sb, indent, separatorAdded );
}
@@ -2527,11 +2553,11 @@ public abstract class AbstractFixJavadoc
* @param sb not null
* @param indent not null
* @param separatorAdded
- * @param javaParameter not null
+ * @param typeParam not null
* @return true if separator has been added.
*/
private boolean appendDefaultParamTag( final StringBuilder sb, final String indent, boolean separatorAdded,
- final JavaParameter javaParameter )
+ final JavaParameter typeParam )
{
if ( !fixTag( PARAM_TAG ) )
{
@@ -2544,7 +2570,7 @@ public abstract class AbstractFixJavadoc
separatorAdded = true;
}
- appendDefaultParamTag( sb, indent, javaParameter );
+ appendDefaultParamTag( sb, indent, typeParam );
return separatorAdded;
}
@@ -2556,7 +2582,7 @@ public abstract class AbstractFixJavadoc
* @return true if separator has been added.
*/
private boolean appendDefaultParamTag( final StringBuilder sb, final String indent, boolean separatorAdded,
- final TypeVariable typeParameter )
+ final JavaTypeVariable<JavaGenericDeclaration> typeParameter )
{
if ( !fixTag( PARAM_TAG ) )
{
@@ -2576,9 +2602,9 @@ public abstract class AbstractFixJavadoc
/**
* @param sb not null
* @param indent not null
- * @param javaParameter not null
+ * @param typeParam not null
*/
- private void appendDefaultParamTag( final StringBuilder sb, final String indent, final JavaParameter javaParameter )
+ private void appendDefaultParamTag( final StringBuilder sb, final String indent, final JavaParameter typeParam )
{
if ( !fixTag( PARAM_TAG ) )
{
@@ -2586,9 +2612,9 @@ public abstract class AbstractFixJavadoc
}
sb.append( indent ).append( " * @" ).append( PARAM_TAG ).append( " " );
- sb.append( javaParameter.getName() );
+ sb.append( typeParam.getName() );
sb.append( " " );
- sb.append( getDefaultJavadocForType( javaParameter.getType() ) );
+ sb.append( getDefaultJavadocForType( typeParam.getJavaClass() ) );
sb.append( EOL );
}
@@ -2597,7 +2623,8 @@ public abstract class AbstractFixJavadoc
* @param indent not null
* @param typeParameter not null
*/
- private void appendDefaultParamTag( final StringBuilder sb, final String indent, final TypeVariable typeParameter )
+ private void appendDefaultParamTag( final StringBuilder sb, final String indent,
+ final JavaTypeVariable<JavaGenericDeclaration> typeParameter )
{
if ( !fixTag( PARAM_TAG ) )
{
@@ -2661,7 +2688,7 @@ public abstract class AbstractFixJavadoc
* @return true if separator has been added.
*/
private boolean appendDefaultThrowsTag( final StringBuilder sb, final String indent, boolean separatorAdded,
- final Type exception )
+ final JavaType exception )
{
if ( !fixTag( THROWS_TAG ) )
{
@@ -2683,7 +2710,7 @@ public abstract class AbstractFixJavadoc
* @param indent not null
* @param exception not null
*/
- private void appendDefaultThrowsTag( final StringBuilder sb, final String indent, final Type exception )
+ private void appendDefaultThrowsTag( final StringBuilder sb, final String indent, final JavaType exception )
{
if ( !fixTag( THROWS_TAG ) )
{
@@ -2691,7 +2718,7 @@ public abstract class AbstractFixJavadoc
}
sb.append( indent ).append( " * @" ).append( THROWS_TAG ).append( " " );
- sb.append( exception.getJavaClass().getFullyQualifiedName() );
+ sb.append( exception.getFullyQualifiedName() );
sb.append( " if any." );
sb.append( EOL );
}
@@ -2714,15 +2741,13 @@ public abstract class AbstractFixJavadoc
* @return <code>true</code> if the method is inherited, <code>false</code> otherwise.
* @throws MojoExecutionException if any
*/
- private boolean isInherited( JavaMethod javaMethod )
+ private boolean isInherited( JavaExecutable javaMethod )
throws MojoExecutionException
{
if ( javaMethod.getAnnotations() != null )
{
- for ( int i = 0; i < javaMethod.getAnnotations().length; i++ )
+ for ( JavaAnnotation annotation : javaMethod.getAnnotations() )
{
- Annotation annotation = javaMethod.getAnnotations()[i];
-
if ( annotation.toString().equals( "@java.lang.Override()" ) )
{
return true;
@@ -2730,7 +2755,7 @@ public abstract class AbstractFixJavadoc
}
}
- Class<?> clazz = getClass( javaMethod.getParentClass().getFullyQualifiedName() );
+ Class<?> clazz = getClass( javaMethod.getDeclaringClass().getFullyQualifiedName() );
List<Class<?>> interfaces = ClassUtils.getAllInterfaces( clazz );
for ( Class<?> intface : interfaces )
@@ -2760,7 +2785,7 @@ public abstract class AbstractFixJavadoc
* <code>false</code> otherwise.
* @see #isInherited(JavaMethod)
*/
- private boolean isInherited( Class<?> clazz, JavaMethod javaMethod )
+ private boolean isInherited( Class<?> clazz, JavaExecutable javaMethod )
{
for ( Method method : clazz.getDeclaredMethods() )
{
@@ -2769,7 +2794,7 @@ public abstract class AbstractFixJavadoc
continue;
}
- if ( method.getParameterTypes().length != javaMethod.getParameters().length )
+ if ( method.getParameterTypes().length != javaMethod.getParameters().size() )
{
continue;
}
@@ -2779,7 +2804,7 @@ public abstract class AbstractFixJavadoc
for ( Class<?> paramType : method.getParameterTypes() )
{
String name1 = paramType.getName();
- String name2 = javaMethod.getParameters()[j++].getType().getFullQualifiedName();
+ String name2 = javaMethod.getParameters().get( j++ ).getType().getFullyQualifiedName();
found = name1.equals( name2 ); // TODO check algo, seems broken (only takes in account the last param)
}
@@ -2790,52 +2815,64 @@ public abstract class AbstractFixJavadoc
}
/**
- * @param type
+ * @param clazz
* @return
*/
- private String getDefaultJavadocForType( Type type )
+ private String getDefaultJavadocForType( JavaClass clazz )
{
StringBuilder sb = new StringBuilder();
- if ( !TypeVariable.class.isAssignableFrom( type.getClass() ) && type.isPrimitive() )
+ if ( !JavaTypeVariable.class.isAssignableFrom( clazz.getClass() ) && clazz.isPrimitive() )
{
- if ( type.isArray() )
+ if ( clazz.isArray() )
{
- sb.append( "an array of " );
+ sb.append( "an array of " ).append( clazz.getComponentType().getCanonicalName() );
}
else
{
- sb.append( "a " );
+ sb.append( "a " ).append( clazz.getCanonicalName() );
}
- return sb.append( type.getJavaClass().getFullyQualifiedName() ).append( "." ).toString();
+ return sb.append( "." ).toString();
}
StringBuilder javadocLink = new StringBuilder();
try
{
- getClass( type.getJavaClass().getFullyQualifiedName() );
+ getClass( clazz.getCanonicalName() );
- String s = type.getJavaClass().getFullyQualifiedName();
- s = StringUtils.replace( s, "$", "." );
-
- javadocLink.append( "{@link " ).append( s ).append( "}" );
+ javadocLink.append( "{@link " );
+
+ if ( clazz.isArray() )
+ {
+ javadocLink.append( clazz.getComponentType().getCanonicalName() );
+ }
+ else
+ {
+ javadocLink.append( clazz.getCanonicalName() );
+ }
+ javadocLink.append( "}" );
}
catch ( Exception e )
{
- javadocLink.append( type.getJavaClass().getFullyQualifiedName() );
+ javadocLink.append( clazz.getValue() );
}
- if ( type.isArray() )
+ if ( clazz.isArray() )
{
- sb.append( "an array of " ).append( javadocLink.toString() ).append( " objects." );
+ sb.append( "an array of " ).append( javadocLink ).append( " objects." );
}
else
{
- sb.append( "a " ).append( javadocLink.toString() ).append( " object." );
+ sb.append( "a " ).append( javadocLink ).append( " object." );
}
return sb.toString();
}
+
+ private String getDefaultJavadocForType( JavaTypeVariable<JavaGenericDeclaration> typeParameter )
+ {
+ return "a " + typeParameter.getName() + " object.";
+ }
/**
* Check under Clirr if this given class is newer from the last version.
@@ -2852,12 +2889,12 @@ public abstract class AbstractFixJavadoc
/**
* Check under Clirr if this given method is newer from the last version.
*
- * @param javaMethod a given method not null
+ * @param javaExecutable a given method not null
* @return <code>true</code> if Clirr said that this method is added from the last version,
* <code>false</code> otherwise or if {@link #clirrNewMethods} is null.
* @throws MojoExecutionException if any
*/
- private boolean isNewMethodFromLastRevision( JavaMethod javaMethod )
+ private boolean isNewMethodFromLastRevision( JavaExecutable javaExecutable )
throws MojoExecutionException
{
if ( clirrNewMethods == null )
@@ -2865,7 +2902,7 @@ public abstract class AbstractFixJavadoc
return false;
}
- List<String> clirrMethods = clirrNewMethods.get( javaMethod.getParentClass().getFullyQualifiedName() );
+ List<String> clirrMethods = clirrNewMethods.get( javaExecutable.getDeclaringClass().getFullyQualifiedName() );
if ( clirrMethods == null )
{
return false;
@@ -2875,20 +2912,20 @@ public abstract class AbstractFixJavadoc
{
// see net.sf.clirr.core.internal.checks.MethodSetCheck#getMethodId(JavaType clazz, Method method)
String retrn = "";
- if ( javaMethod.getReturns() != null )
+ if ( javaExecutable instanceof JavaMethod && ( (JavaMethod) javaExecutable ).getReturns() != null )
{
- retrn = javaMethod.getReturns().getFullQualifiedName();
+ retrn = ( (JavaMethod) javaExecutable ).getReturns().getFullyQualifiedName();
}
StringBuilder params = new StringBuilder();
- for ( JavaParameter parameter : javaMethod.getParameters() )
+ for ( JavaParameter parameter : javaExecutable.getParameters() )
{
if ( params.length() > 0 )
{
params.append( ", " );
}
- params.append( parameter.getResolvedValue() );
+ params.append( parameter.getResolvedFullyQualifiedName() );
}
- if ( clirrMethod.contains( retrn + " " ) && clirrMethod.contains( javaMethod.getName() + "(" )
+ if ( clirrMethod.contains( retrn + " " ) && clirrMethod.contains( javaExecutable.getName() + "(" )
&& clirrMethod.contains( "(" + params.toString() + ")" ) )
{
return true;
@@ -3062,7 +3099,7 @@ public abstract class AbstractFixJavadoc
StringBuilder sb = new StringBuilder();
sb.append( "<p>" );
- if ( Arrays.asList( javaClass.getModifiers() ).contains( "abstract" ) )
+ if ( javaClass.isAbstract() )
{
sb.append( "Abstract " );
}
@@ -3086,36 +3123,36 @@ public abstract class AbstractFixJavadoc
/**
* Default comment for method with taking care of getter/setter in the javaMethod name.
*
- * @param javaMethod not null
+ * @param javaExecutable not null
* @return a default comment for method.
*/
- private static String getDefaultMethodJavadocComment( final JavaMethod javaMethod )
+ private static String getDefaultMethodJavadocComment( final JavaExecutable javaExecutable )
{
- if ( javaMethod.isConstructor() )
+ if ( javaExecutable instanceof JavaConstructor )
{
- return "<p>Constructor for " + javaMethod.getName() + ".</p>";
+ return "<p>Constructor for " + javaExecutable.getName() + ".</p>";
}
-
- if ( javaMethod.getName().length() > 3 && ( javaMethod.getName().startsWith( "get" )
- || javaMethod.getName().startsWith( "set" ) ) )
+
+ if ( javaExecutable.getName().length() > 3 && ( javaExecutable.getName().startsWith( "get" )
+ || javaExecutable.getName().startsWith( "set" ) ) )
{
- String field = StringUtils.lowercaseFirstLetter( javaMethod.getName().substring( 3 ) );
+ String field = StringUtils.lowercaseFirstLetter( javaExecutable.getName().substring( 3 ) );
- JavaClass clazz = javaMethod.getParentClass();
+ JavaClass clazz = javaExecutable.getDeclaringClass();
if ( clazz.getFieldByName( field ) == null )
{
- return "<p>" + javaMethod.getName() + ".</p>";
+ return "<p>" + javaExecutable.getName() + ".</p>";
}
StringBuilder sb = new StringBuilder();
sb.append( "<p>" );
- if ( javaMethod.getName().startsWith( "get" ) )
+ if ( javaExecutable.getName().startsWith( "get" ) )
{
sb.append( "Getter " );
}
- else if ( javaMethod.getName().startsWith( "set" ) )
+ else if ( javaExecutable.getName().startsWith( "set" ) )
{
sb.append( "Setter " );
}
@@ -3124,7 +3161,7 @@ public abstract class AbstractFixJavadoc
return sb.toString();
}
- return "<p>" + javaMethod.getName() + ".</p>";
+ return "<p>" + javaExecutable.getName() + ".</p>";
}
/**
@@ -3187,7 +3224,7 @@ public abstract class AbstractFixJavadoc
* @return the javadoc comment for the entity without any tags.
* @throws IOException if any
*/
- private static String getJavadocComment( final String javaClassContent, final AbstractJavaEntity entity )
+ static String getJavadocComment( final String javaClassContent, final JavaAnnotatedElement entity )
throws IOException
{
if ( entity.getComment() == null )
@@ -3253,19 +3290,19 @@ public abstract class AbstractFixJavadoc
* @return the javadoc comment for the entity without Javadoc tags.
* @throws IOException if any
*/
- private String getJavadocComment( final String javaClassContent, final AbstractInheritableJavaEntity entity,
+ String getJavadocComment( final String javaClassContent, final JavaAnnotatedElement entity,
final DocletTag docletTag )
throws IOException
{
- if ( docletTag.getValue() == null || docletTag.getParameters().length == 0 )
+ if ( docletTag.getValue() == null || docletTag.getParameters().isEmpty() )
{
return "";
}
String originalJavadoc = extractOriginalJavadocContent( javaClassContent, entity );
- String[] params = fixQdox173( docletTag.getParameters() );
- String paramValue = params[0];
+ List<String> params = docletTag.getParameters();
+ String paramValue = params.get( 0 );
StringBuilder sb = new StringBuilder();
BufferedReader lr = new BufferedReader( new StringReader( originalJavadoc ) );
@@ -3349,7 +3386,7 @@ public abstract class AbstractFixJavadoc
* @return return the original javadoc as String for the current entity
* @throws IOException if any
*/
- private static String extractOriginalJavadoc( final String javaClassContent, final AbstractJavaEntity entity )
+ static String extractOriginalJavadoc( final String javaClassContent, final JavaAnnotatedElement entity )
throws IOException
{
if ( entity.getComment() == null )
@@ -3416,8 +3453,8 @@ public abstract class AbstractFixJavadoc
* @return return the original javadoc as String for the current entity
* @throws IOException if any
*/
- private static String extractOriginalJavadocContent( final String javaClassContent,
- final AbstractJavaEntity entity )
+ static String extractOriginalJavadocContent( final String javaClassContent,
+ final JavaAnnotatedElement entity )
throws IOException
{
if ( entity.getComment() == null )
@@ -3452,7 +3489,7 @@ public abstract class AbstractFixJavadoc
* @param content not null
* @return the content without last lines containing javadoc separator (ie <code> * </code>)
* @throws IOException if any
- * @see #getJavadocComment(String, AbstractInheritableJavaEntity, DocletTag)
+ * @see #getJavadocComment(String, JavaAnnotatedElement, DocletTag)
*/
private static String removeLastEmptyJavadocLines( final String content )
throws IOException
@@ -3495,7 +3532,7 @@ public abstract class AbstractFixJavadoc
* @param content not null
* @return the javadoc comment with the given indentation
* @throws IOException if any
- * @see #getJavadocComment(String, AbstractInheritableJavaEntity, DocletTag)
+ * @see #getJavadocComment(String, JavaAnnotatedElement, DocletTag)
*/
private static String alignIndentationJavadocLines( final String content, final String indent )
throws IOException
@@ -3609,39 +3646,13 @@ public abstract class AbstractFixJavadoc
return text.substring( 0, text.indexOf( textTrimmed ) + textTrimmed.length() );
}
- /**
- * Workaroung for QDOX-173 about generic.
- *
- * @param params not null
- * @return the wanted params.
- */
- private static String[] fixQdox173( String[] params )
- {
- if ( params == null || params.length == 0 || params.length < 3 )
- {
- return params;
- }
-
- if ( params[0].trim().equals( "<" ) && params[2].trim().equals( ">" ) )
- {
- String param = params[1];
- List<String> l = new ArrayList<>( Arrays.asList( params ) );
- l.set( 1, "<" + param + ">" );
- l.remove( 0 );
- l.remove( 1 );
-
- return l.toArray( new String[l.size()] );
- }
-
- return params;
- }
/**
* Wrapper class for the entity's tags.
*/
class JavaEntityTags
{
- private final AbstractInheritableJavaEntity entity;
+ private final JavaAnnotatedElement entity;
private final boolean isJavaMethod;
@@ -3670,7 +3681,7 @@ public abstract class AbstractFixJavadoc
*/
private List<String> unknownsTags;
- public JavaEntityTags( AbstractInheritableJavaEntity entity, boolean isJavaMethod )
+ public JavaEntityTags( JavaAnnotatedElement entity, boolean isJavaMethod )
{
this.entity = entity;
this.isJavaMethod = isJavaMethod;
Modified: maven/plugins/trunk/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/AbstractFixJavadocMojoTest.java
URL: http://svn.apache.org/viewvc/maven/plugins/trunk/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/AbstractFixJavadocMojoTest.java?rev=1804865&r1=1804864&r2=1804865&view=diff
==============================================================================
--- maven/plugins/trunk/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/AbstractFixJavadocMojoTest.java (original)
+++ maven/plugins/trunk/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/AbstractFixJavadocMojoTest.java Sat Aug 12 13:15:49 2017
@@ -9,7 +9,7 @@ package org.apache.maven.plugins.javadoc
* "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
+ * 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
@@ -19,35 +19,34 @@ package org.apache.maven.plugins.javadoc
* under the License.
*/
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.when;
+import java.io.StringReader;
-import org.apache.maven.plugins.javadoc.AbstractFixJavadocMojo;
+import com.thoughtworks.qdox.JavaProjectBuilder;
+import com.thoughtworks.qdox.model.JavaClass;
+import com.thoughtworks.qdox.model.JavaSource;
import junit.framework.TestCase;
-import junitx.util.PrivateAccessor;
-
-import com.thoughtworks.qdox.model.AbstractInheritableJavaEntity;
-import com.thoughtworks.qdox.model.DocletTag;
-import com.thoughtworks.qdox.model.IndentBuffer;
-import com.thoughtworks.qdox.model.JavaClass;
public class AbstractFixJavadocMojoTest
extends TestCase
{
+ private JavaSource getJavaSource( String source )
+ {
+ return new JavaProjectBuilder().addSource( new StringReader( source ) );
+ }
public void testReplaceLinkTags_noLinkTag()
throws Throwable
{
String comment = "/** @see ConnectException */";
- AbstractInheritableJavaEntity entity = spy( new PrivateAbstractInheritableJavaEntity() );
- JavaClass clazz = mock( JavaClass.class );
- when( entity.getParentClass() ).thenReturn( clazz );
- when( clazz.resolveType( "ConnectException" ) ).thenReturn( "java.net.ConnectException" );
- String newComment =
- (String) PrivateAccessor.invoke( AbstractFixJavadocMojo.class, "replaceLinkTags", new Class[] {
- String.class, AbstractInheritableJavaEntity.class }, new Object[] { comment, entity } );
+ String source = "import java.net.ConnectException;\n"
+ + comment + "\n"
+ + "public class NoLinkTag {}";
+
+ JavaClass clazz = getJavaSource( source ).getClassByName( "NoLinkTag" );
+
+ String newComment = AbstractFixJavadocMojo.replaceLinkTags( comment, clazz );
+
assertEquals( "/** @see ConnectException */", newComment );
}
@@ -55,13 +54,13 @@ public class AbstractFixJavadocMojoTest
throws Throwable
{
String comment = "/** {@link ConnectException} */";
- AbstractInheritableJavaEntity entity = spy( new PrivateAbstractInheritableJavaEntity() );
- JavaClass clazz = mock( JavaClass.class );
- when( entity.getParentClass() ).thenReturn( clazz );
- when( clazz.resolveType( "ConnectException" ) ).thenReturn( "java.net.ConnectException" );
- String newComment =
- (String) PrivateAccessor.invoke( AbstractFixJavadocMojo.class, "replaceLinkTags", new Class[] {
- String.class, AbstractInheritableJavaEntity.class }, new Object[] { comment, entity } );
+ String source = "import java.net.ConnectException;\n"
+ + comment + "\n"
+ + "public class OneLinkTag {}";
+
+ JavaClass clazz = getJavaSource( source ).getClassByName( "OneLinkTag" );
+
+ String newComment = AbstractFixJavadocMojo.replaceLinkTags( comment, clazz );
assertEquals( "/** {@link java.net.ConnectException} */", newComment );
}
@@ -69,14 +68,13 @@ public class AbstractFixJavadocMojoTest
throws Throwable
{
String comment = "/** {@link ConnectException */";
- AbstractInheritableJavaEntity entity = spy( new PrivateAbstractInheritableJavaEntity() );
- JavaClass clazz = mock( JavaClass.class );
- when( entity.getParentClass() ).thenReturn( clazz );
- when( clazz.resolveType( "ConnectException" ) ).thenReturn( "java.net.ConnectException" );
- String newComment =
- (String) PrivateAccessor.invoke( AbstractFixJavadocMojo.class, "replaceLinkTags", new Class[] {
- String.class, AbstractInheritableJavaEntity.class }, new Object[] { comment, entity } );
-
+ String source = "import java.net.ConnectException;\n"
+ + comment + "\n"
+ + "public class MissingEndBrace {}";
+
+ JavaClass clazz = getJavaSource( source ).getClassByName( "MissingEndBrace" );
+
+ String newComment = AbstractFixJavadocMojo.replaceLinkTags( comment, clazz );
assertEquals( "/** {@link ConnectException */", newComment );
}
@@ -84,14 +82,13 @@ public class AbstractFixJavadocMojoTest
throws Throwable
{
String comment = "/** {@link ConnectException} */";
- AbstractInheritableJavaEntity entity = spy( new PrivateAbstractInheritableJavaEntity() );
- JavaClass clazz = mock( JavaClass.class );
- when( entity.getParentClass() ).thenReturn( clazz );
- when( clazz.resolveType( "ConnectException" ) ).thenReturn( "java.net.ConnectException" );
- String newComment =
- (String) PrivateAccessor.invoke( AbstractFixJavadocMojo.class, "replaceLinkTags", new Class[] {
- String.class, AbstractInheritableJavaEntity.class }, new Object[] { comment, entity } );
-
+ String source = "import java.net.ConnectException;\n"
+ + comment + "\n"
+ + "public class SpacesAfterLinkTag {}";
+
+ JavaClass clazz = getJavaSource( source ).getClassByName( "SpacesAfterLinkTag" );
+
+ String newComment = AbstractFixJavadocMojo.replaceLinkTags( comment, clazz );
assertEquals( "/** {@link java.net.ConnectException} */", newComment );
}
@@ -99,14 +96,13 @@ public class AbstractFixJavadocMojoTest
throws Throwable
{
String comment = "/** {@link ConnectException } */";
- AbstractInheritableJavaEntity entity = spy( new PrivateAbstractInheritableJavaEntity() );
- JavaClass clazz = mock( JavaClass.class );
- when( entity.getParentClass() ).thenReturn( clazz );
- when( clazz.resolveType( "ConnectException" ) ).thenReturn( "java.net.ConnectException" );
- String newComment =
- (String) PrivateAccessor.invoke( AbstractFixJavadocMojo.class, "replaceLinkTags", new Class[] {
- String.class, AbstractInheritableJavaEntity.class }, new Object[] { comment, entity } );
-
+ String source = "import java.net.ConnectException;\n"
+ + comment + "\n"
+ + "public class SpacesAfterClassName {}";
+
+ JavaClass clazz = getJavaSource( source ).getClassByName( "SpacesAfterClassName" );
+
+ String newComment = AbstractFixJavadocMojo.replaceLinkTags( comment, clazz );
assertEquals( "/** {@link java.net.ConnectException} */", newComment );
}
@@ -114,14 +110,13 @@ public class AbstractFixJavadocMojoTest
throws Throwable
{
String comment = "/** {@link ConnectException#getMessage() } */";
- AbstractInheritableJavaEntity entity = spy( new PrivateAbstractInheritableJavaEntity() );
- JavaClass clazz = mock( JavaClass.class );
- when( entity.getParentClass() ).thenReturn( clazz );
- when( clazz.resolveType( "ConnectException" ) ).thenReturn( "java.net.ConnectException" );
- String newComment =
- (String) PrivateAccessor.invoke( AbstractFixJavadocMojo.class, "replaceLinkTags", new Class[] {
- String.class, AbstractInheritableJavaEntity.class }, new Object[] { comment, entity } );
+ String source = "import java.net.ConnectException;\n"
+ + comment + "\n"
+ + "public class SpacesAfterMethod {}";
+
+ JavaClass clazz = getJavaSource( source ).getClassByName( "SpacesAfterMethod" );
+ String newComment = AbstractFixJavadocMojo.replaceLinkTags( comment, clazz );
assertEquals( "/** {@link java.net.ConnectException#getMessage()} */", newComment );
}
@@ -129,14 +124,13 @@ public class AbstractFixJavadocMojoTest
throws Throwable
{
String comment = "/** {@link ConnectException#getMessage()} */";
- AbstractInheritableJavaEntity entity = spy( new PrivateAbstractInheritableJavaEntity() );
- JavaClass clazz = mock( JavaClass.class );
- when( entity.getParentClass() ).thenReturn( clazz );
- when( clazz.resolveType( "ConnectException" ) ).thenReturn( "java.net.ConnectException" );
- String newComment =
- (String) PrivateAccessor.invoke( AbstractFixJavadocMojo.class, "replaceLinkTags", new Class[] {
- String.class, AbstractInheritableJavaEntity.class }, new Object[] { comment, entity } );
+ String source = "import java.net.ConnectException;\n"
+ + comment + "\n"
+ + "public class ContainingHashes {}";
+
+ JavaClass clazz = getJavaSource( source ).getClassByName( "ContainingHashes" );
+ String newComment = AbstractFixJavadocMojo.replaceLinkTags( comment, clazz );
assertEquals( "/** {@link java.net.ConnectException#getMessage()} */", newComment );
}
@@ -144,14 +138,13 @@ public class AbstractFixJavadocMojoTest
throws Throwable
{
String comment = "/** {@link ConnectException} ##important## */";
- AbstractInheritableJavaEntity entity = spy( new PrivateAbstractInheritableJavaEntity() );
- JavaClass clazz = mock( JavaClass.class );
- when( entity.getParentClass() ).thenReturn( clazz );
- when( clazz.resolveType( "ConnectException" ) ).thenReturn( "java.net.ConnectException" );
- String newComment =
- (String) PrivateAccessor.invoke( AbstractFixJavadocMojo.class, "replaceLinkTags", new Class[] {
- String.class, AbstractInheritableJavaEntity.class }, new Object[] { comment, entity } );
+ String source = "import java.net.ConnectException;\n"
+ + comment + "\n"
+ + "public class FollowedByHash {}";
+
+ JavaClass clazz = getJavaSource( source ).getClassByName( "FollowedByHash" );
+ String newComment = AbstractFixJavadocMojo.replaceLinkTags( comment, clazz );
assertEquals( "/** {@link java.net.ConnectException} ##important## */", newComment );
}
@@ -159,15 +152,13 @@ public class AbstractFixJavadocMojoTest
throws Throwable
{
String comment = "/** Use {@link ConnectException} instead of {@link Exception} */";
- AbstractInheritableJavaEntity entity = spy( new PrivateAbstractInheritableJavaEntity() );
- JavaClass clazz = mock( JavaClass.class );
- when( entity.getParentClass() ).thenReturn( clazz );
- when( clazz.resolveType( "ConnectException" ) ).thenReturn( "java.net.ConnectException" );
- when( clazz.resolveType( "Exception" ) ).thenReturn( "java.lang.Exception" );
- String newComment =
- (String) PrivateAccessor.invoke( AbstractFixJavadocMojo.class, "replaceLinkTags", new Class[] {
- String.class, AbstractInheritableJavaEntity.class }, new Object[] { comment, entity } );
+ String source = "import java.net.ConnectException;\n"
+ + comment + "\n"
+ + "public class TwoLinks {}";
+
+ JavaClass clazz = getJavaSource( source ).getClassByName( "TwoLinks" );
+ String newComment = AbstractFixJavadocMojo.replaceLinkTags( comment, clazz );
assertEquals( "/** Use {@link java.net.ConnectException} instead of {@link java.lang.Exception} */", newComment );
}
@@ -175,37 +166,13 @@ public class AbstractFixJavadocMojoTest
throws Throwable
{
String comment = "/** There's a {@link #getClass()} but no setClass() */";
- AbstractInheritableJavaEntity entity = spy( new PrivateAbstractInheritableJavaEntity() );
- JavaClass clazz = mock( JavaClass.class );
- when( entity.getParentClass() ).thenReturn( clazz );
- when( clazz.resolveType( "ConnectException" ) ).thenReturn( "java.net.ConnectException" );
- when( clazz.resolveType( "Exception" ) ).thenReturn( "java.lang.Exception" );
-
- String newComment =
- (String) PrivateAccessor.invoke( AbstractFixJavadocMojo.class, "replaceLinkTags", new Class[] {
- String.class, AbstractInheritableJavaEntity.class }, new Object[] { comment, entity } );
+ String source = "import java.net.ConnectException;\n"
+ + comment + "\n"
+ + "public class OnlyAnchor {}";
+
+ JavaClass clazz = getJavaSource( source ).getClassByName( "OnlyAnchor" );
+ String newComment = AbstractFixJavadocMojo.replaceLinkTags( comment, clazz );
assertEquals( "/** There's a {@link #getClass()} but no setClass() */", newComment );
}
-
- protected class PrivateAbstractInheritableJavaEntity
- extends AbstractInheritableJavaEntity
- {
- @Override
- public int compareTo( Object o )
- {
- return 0;
- }
-
- @Override
- public DocletTag[] getTagsByName( String arg0, boolean arg1 )
- {
- return null;
- }
-
- @Override
- protected void writeBody( IndentBuffer arg0 )
- {
- }
- }
}