private void buildResponseErrors(Method method, MethodDocument document, JavaMethod javaMethod) {
final DocletTag[] errorStatuses = javaMethod.getTagsByName("error.status");
final DocletTag[] errorCauses = javaMethod.getTagsByName("error.cause");
int totalErrors = errorCauses.length;
if (errorStatuses.length != errorCauses.length) {
LOG.warn(
"For method {}, the number of tags @error.status is different than the"
+ " number of tags @error.cause; Because of this, the {} will only use the minimum"
+ " count from the two.",
method.getName(),
this.getClass().getName());
totalErrors = Math.min(errorCauses.length, errorStatuses.length);
}
List<ResponseError> errors = new ArrayList<ResponseError>(totalErrors);
for (int i = 0; i < totalErrors; i++) {
try {
errors.add(
new ResponseError(
Integer.parseInt(errorStatuses[i].getValue()), errorCauses[i].getValue()));
} catch (NumberFormatException e) {
LOG.error("Invalid number for @error.status: " + errorStatuses[i].getValue());
}
}
document.setResponseErrors(ImmutableList.copyOf(errors));
}
private void _addReturnElement(Element methodElement, JavaMethod javaMethod) throws Exception {
Type returns = javaMethod.getReturns();
if (returns == null) {
return;
}
String returnsValue = returns.getValue();
if (returnsValue.equals("void")) {
return;
}
Element returnElement = methodElement.addElement("return");
DocletTag[] returnDocletTags = javaMethod.getTagsByName("return");
String comment = StringPool.BLANK;
if (returnDocletTags.length > 0) {
DocletTag returnDocletTag = returnDocletTags[0];
comment = GetterUtil.getString(returnDocletTag.getValue());
DocUtil.add(returnElement, "required", true);
}
comment = _trimMultilineText(comment);
Element commentElement = returnElement.addElement("comment");
commentElement.addCDATA(comment);
}
/**
* Get ITestNGMethod author(s) string, or class author(s) if no method author is present. Default
* return value is "unknown".
*
* @param className
* @param method
* @return
* @author hzjingcheng
*/
private String getAuthors(String className, ITestNGMethod method) {
JavaClass cls = builder.getClassByName(className);
DocletTag[] authors = cls.getTagsByName("author");
// get class authors as default author name
String allAuthors = "";
if (authors.length == 0) {
allAuthors = "unknown";
} else {
for (DocletTag author : authors) {
allAuthors += author.getValue() + " ";
}
}
// get method author name
JavaMethod[] mtds = cls.getMethods();
for (JavaMethod mtd : mtds) {
if (mtd.getName().equals(method.getMethodName())) {
authors = mtd.getTagsByName("author");
if (authors.length != 0) {
allAuthors = "";
for (DocletTag author : authors) {
allAuthors += author.getValue() + " ";
}
}
break;
}
}
return allAuthors.trim();
}
private static void ppp(String s) {
JavaClass jc = null;
// jc.getMethods()[0].getParameters()[0].getType().getGenericValue()
// jc.getFields()[0].getTagByName("").getParameters()
// jc.getFullyQualifiedName()
JavaMethod jm = null;
jm.getTagsByName("aa");
System.out.println("[DoclipseJavaDocProcessor] " + s);
}
private void _addThrowsElements(Element methodElement, JavaMethod javaMethod) {
Type[] exceptionTypes = javaMethod.getExceptions();
DocletTag[] throwsDocletTags = javaMethod.getTagsByName("throws");
for (Type exceptionType : exceptionTypes) {
_addThrowsElement(methodElement, exceptionType, throwsDocletTags);
}
}
private void _addParamElements(Element methodElement, JavaMethod javaMethod) {
JavaParameter[] javaParameters = javaMethod.getParameters();
DocletTag[] paramDocletTags = javaMethod.getTagsByName("param");
for (JavaParameter javaParameter : javaParameters) {
_addParamElement(methodElement, javaParameter, paramDocletTags);
}
}
// Processes parameters of javaMethod and enters the proper key-values into the methodNode
private void processParameters(JavaMethod javaMethod, ObjectNode methodNode) {
ArrayNode parameters = mapper.createArrayNode();
methodNode.set("parameters", parameters);
boolean required = true;
for (JavaParameter javaParameter : javaMethod.getParameters()) {
ObjectNode individualParameterNode = mapper.createObjectNode();
Optional<JavaAnnotation> optional =
javaParameter
.getAnnotations()
.stream()
.filter(
annotation ->
annotation.getType().getName().equals(PATH_PARAM)
|| annotation.getType().getName().equals(QUERY_PARAM))
.findAny();
JavaAnnotation pathType = optional.isPresent() ? optional.get() : null;
String annotationName = javaParameter.getName();
if (pathType != null) { // the parameter is a path or query parameter
individualParameterNode.put(
"name", pathType.getNamedParameter("value").toString().replace("\"", ""));
if (pathType.getType().getName().equals(PATH_PARAM)) {
individualParameterNode.put("in", "path");
} else if (pathType.getType().getName().equals(QUERY_PARAM)) {
individualParameterNode.put("in", "query");
}
individualParameterNode.put("type", getType(javaParameter.getType()));
} else { // the parameter is a body parameter
individualParameterNode.put("name", annotationName);
individualParameterNode.put("in", "body");
// TODO add actual hardcoded schemas and a type
// body parameters must have a schema associated with them
ArrayNode schema = mapper.createArrayNode();
individualParameterNode.set("schema", schema);
}
for (DocletTag p : javaMethod.getTagsByName("param")) {
if (p.getValue().contains(annotationName)) {
try {
String description = p.getValue().split(" ", 2)[1].trim();
if (description.contains("optional")) {
required = false;
}
individualParameterNode.put("description", description);
} catch (Exception e) {
e.printStackTrace();
}
}
}
individualParameterNode.put("required", required);
parameters.add(individualParameterNode);
}
}
private void buildQueryAndPathDocuments(
Method method, JavaMethod javaMethod, MethodDocument document) {
if (method.getParameterTypes().length != javaMethod.getParameters().length) {
LOG.error(
"Unable to generate argument documentation: number of method arguments is not "
+ "the same as number of @param found in javadoc.");
return;
}
List<ParamDocument> queryParams = new ArrayList<ParamDocument>();
List<ParamDocument> pathParams = new ArrayList<ParamDocument>();
Annotation[][] annotations = method.getParameterAnnotations();
for (int i = 0; i < annotations.length; i++) {
JavaParameter javaParameter = javaMethod.getParameters()[i];
DocletTag javaParameterTag = javaMethod.getTagsByName("param")[i];
// Check annotations at parameter i
for (Annotation a : annotations[i]) {
if (a.annotationType() == QueryParam.class) {
queryParams.add(
new ParamDocument(
javaParameter.getName(),
extractParameterValue(javaParameterTag, javaParameter.getName())));
} else if (a.annotationType() == PathParam.class) {
pathParams.add(
new ParamDocument(
javaParameter.getName(),
extractParameterValue(javaParameterTag, javaParameter.getName())));
}
}
}
LOG.info("Found {} query params for method {}", queryParams.size(), method.getName());
LOG.info("Found {} path params for method {}", pathParams.size(), method.getName());
document.setQueryParams(ImmutableList.copyOf(queryParams));
document.setPathParams(ImmutableList.copyOf(pathParams));
}
private void buildExamples(JavaMethod javaMethod, MethodDocument document) {
final DocletTag[] exampleTitles = javaMethod.getTagsByName("example.title");
final DocletTag[] exampleDescriptions = javaMethod.getTagsByName("example.description");
final DocletTag[] exampleRequests = javaMethod.getTagsByName("example.request");
final DocletTag[] exampleRequestsContentType =
javaMethod.getTagsByName("example.requestContentType");
final DocletTag[] exampleResponses = javaMethod.getTagsByName("example.response");
final DocletTag[] exampleResponsesContentType =
javaMethod.getTagsByName("example.responseContentType");
if ((exampleTitles.length != exampleDescriptions.length)
|| (exampleTitles.length != exampleRequests.length)
|| (exampleTitles.length != exampleRequestsContentType.length)
|| (exampleTitles.length != exampleResponses.length)
|| (exampleTitles.length != exampleResponsesContentType.length)) {
LOG.error(
"Unable to build examples. The number of tags "
+ "example/title,description,request,requestContentType,response,responseContentType "
+ "must be equal.");
return;
}
List<ApiExampleDocument> examples = new ArrayList<ApiExampleDocument>();
for (int i = 0; i < exampleTitles.length; i++) {
ApiExampleDocument example =
new ApiExampleDocument(
exampleTitles[i].getValue(),
exampleDescriptions[i].getValue(),
exampleRequests[i].getValue(),
exampleRequestsContentType[i].getValue(),
exampleResponses[i].getValue(),
exampleResponsesContentType[i].getValue());
LOG.info("Added new example for {}: {}", document.getPath(), example);
examples.add(example);
}
document.setExampleDocuments(ImmutableList.copyOf(examples));
}
// Processes parameters of javaMethod and enters the proper key-values into the methodNode
private void processParameters(
JavaMethod javaMethod, ObjectNode methodNode, String method, DocletTag tag) {
ArrayNode parameters = mapper.createArrayNode();
methodNode.set("parameters", parameters);
boolean required = true;
for (JavaParameter javaParameter : javaMethod.getParameters()) {
ObjectNode individualParameterNode = mapper.createObjectNode();
Optional<JavaAnnotation> optional =
javaParameter
.getAnnotations()
.stream()
.filter(
annotation ->
annotation.getType().getName().equals(PATH_PARAM)
|| annotation.getType().getName().equals(QUERY_PARAM))
.findAny();
JavaAnnotation pathType = optional.isPresent() ? optional.get() : null;
String annotationName = javaParameter.getName();
if (pathType != null) { // the parameter is a path or query parameter
individualParameterNode.put(
"name", pathType.getNamedParameter("value").toString().replace("\"", ""));
if (pathType.getType().getName().equals(PATH_PARAM)) {
individualParameterNode.put("in", "path");
} else if (pathType.getType().getName().equals(QUERY_PARAM)) {
individualParameterNode.put("in", "query");
}
individualParameterNode.put("type", getType(javaParameter.getType()));
} else { // the parameter is a body parameter
individualParameterNode.put("name", annotationName);
individualParameterNode.put("in", "body");
// Adds the reference to the Json model for the input
// that goes in the post or put operation
if (tag != null
&& (method.toLowerCase().equals("post") || method.toLowerCase().equals("put"))) {
ObjectNode schema = mapper.createObjectNode();
tag.getParameters()
.stream()
.forEach(
param -> {
schema.put("$ref", "#/definitions/" + param);
});
individualParameterNode.set("schema", schema);
}
}
for (DocletTag p : javaMethod.getTagsByName("param")) {
if (p.getValue().contains(annotationName)) {
try {
String description = p.getValue().split(" ", 2)[1].trim();
if (description.contains("optional")) {
required = false;
}
individualParameterNode.put("description", description);
} catch (Exception e) {
e.printStackTrace();
}
}
}
individualParameterNode.put("required", required);
parameters.add(individualParameterNode);
}
}