/** * Returns an array containing all of the "test" methods (including those that are inherited) for * the given class. */ private static MethodDoc[] getTestMethods(ClassDoc c) { Set set = new TreeSet(); while (c != null) { MethodDoc[] methods = c.methods(); for (int i = 0; i < methods.length; i++) { MethodDoc method = methods[i]; if (method.isPublic() && method.parameters().length == 0 && method.name().startsWith("test")) { set.add(method); } } c = c.superclass(); } return (MethodDoc[]) set.toArray(new MethodDoc[0]); }
private static void addParamDocs(final MethodDoc methodDoc, final MethodDocType methodDocType, final DocProcessor docProcessor) { final Parameter[] parameters = methodDoc.parameters(); final ParamTag[] paramTags = methodDoc.paramTags();
for (ClassDoc classDoc : root.classes()) { for (MethodDoc methodDoc : classDoc.methods()) { if (methodDoc.parameters() != null) { for (Parameter p : methodDoc.parameters()) { System.out.println(p.name()); } } } }
private Stream<com.sun.javadoc.Parameter> streamPayloadParameterCandidates(MethodDoc methodDoc) { return asList(methodDoc.parameters()).stream() // its a parameter with NO jaxrs annotation .filter(p -> !ParserHelper.hasJaxRsAnnotation(p, options)); }
private Option<com.sun.javadoc.Parameter> findJParameter(MethodDoc methodDoc, String swaggerParameterName) { return option(Arrays.stream(methodDoc.parameters()) .filter(p -> swaggerToJavadocMatch(swaggerParameterName, p)) .findFirst() .orElse(null)); }
/** * @param implClass * @param implMethods * @param md * @return */ private static Method getMethod(final Method[] implMethods, final MethodDoc md) { Method rtn = null; int desiredNumberOfParams = 0; final Parameter[] parameters = md.parameters(); if (parameters != null) { desiredNumberOfParams = parameters.length; } final List<Method> candidateMethods = new ArrayList<Method>(); // try and match by name for (final Method m : implMethods) { if (m.getName().equals(md.name())) { if (m.getParameterTypes().length == desiredNumberOfParams) { candidateMethods.add(m); } } } if (candidateMethods.size() > 1) { throw new IllegalStateException("need to impl parameter type matching"); } if (!candidateMethods.isEmpty()) { rtn = candidateMethods.get(0); } return rtn; }
/** * Returns an array containing all of the "test" methods (including * those that are inherited) for the given class. */ private static MethodDoc[] getTestMethods(ClassDoc c) { Set set = new TreeSet(); while (c != null) { MethodDoc[] methods = c.methods(); for (int i = 0; i < methods.length; i++) { MethodDoc method = methods[i]; if (method.isPublic() && method.parameters().length == 0 && method.name().startsWith("test")) { set.add(method); } } c = c.superclass(); } return (MethodDoc[]) set.toArray(new MethodDoc[0]); }
private boolean isPropertyMethod(MethodDoc method) { if (!method.name().endsWith("Property")) { return false; } if (! memberIsVisible(method)) { return false; } if (pattern.matcher(method.name()).matches()) { return false; } return 0 == method.parameters().length && !"void".equals(method.returnType().simpleTypeName()); }
public static MethodIdentity create(MethodDoc method) { final List<String> parameterTypeNames = new ArrayList<String>(); for (Parameter param: method.parameters()) { Type type = param.type(); parameterTypeNames.add(type.qualifiedTypeName() + type.dimension()); } return new MethodIdentity(method.qualifiedName(), parameterTypeNames); }
private MethodDoc setterForField(MethodDoc[] methods, MethodDoc propertyMethod) { final String propertyMethodName = propertyMethod.name(); final String fieldName = propertyMethodName.substring(0, propertyMethodName.lastIndexOf("Property")); final String fieldNameUppercased = "" + Character.toUpperCase(fieldName.charAt(0)) + fieldName.substring(1); final String setter = "set" + fieldNameUppercased; for (MethodDoc methodDoc : methods) { if (setter.equals(methodDoc.name())) { if (1 == methodDoc.parameters().length && "void".equals(methodDoc.returnType().simpleTypeName()) && (methodDoc.isPublic() || methodDoc.isProtected())) { return methodDoc; } } } return null; }
private MethodDoc getterForField(MethodDoc[] methods, MethodDoc propertyMethod) { final String propertyMethodName = propertyMethod.name(); final String fieldName = propertyMethodName.substring(0, propertyMethodName.lastIndexOf("Property")); final String fieldNameUppercased = "" + Character.toUpperCase(fieldName.charAt(0)) + fieldName.substring(1); final String getterNamePattern; final String fieldTypeName = propertyMethod.returnType().toString(); if ("boolean".equals(fieldTypeName) || fieldTypeName.endsWith("BooleanProperty")) { getterNamePattern = "(is|get)" + fieldNameUppercased; } else { getterNamePattern = "get" + fieldNameUppercased; } for (MethodDoc methodDoc : methods) { if (Pattern.matches(getterNamePattern, methodDoc.name())) { if (0 == methodDoc.parameters().length && (methodDoc.isPublic() || methodDoc.isProtected())) { return methodDoc; } } } return null; }
private static Option<Class<?>[]> loadParameterClasses(MethodDoc methodDoc) { Parameter[] jp = methodDoc.parameters(); List<Class<?>> parameters = new ArrayList<>(); for (Parameter p : jp) { final String classForName = getClassForNameFromType(p.type()); Option<Class<?>> clz = loadClass(classForName); if (clz.isEmpty()) { log.error("Could not load Class.forName({}). Returning no parameters for {}.", classForName, methodDoc.name()); return none(); } parameters.add(clz.get()); } return some(parameters.toArray(new Class[parameters.size()])); }
/** * The documentation for values() and valueOf() in Enums are set by the * doclet. */ public static void setEnumDocumentation(Configuration configuration, ClassDoc classDoc) { MethodDoc[] methods = classDoc.methods(); for (int j = 0; j < methods.length; j++) { MethodDoc currentMethod = methods[j]; if (currentMethod.name().equals("values") && currentMethod.parameters().length == 0) { currentMethod.setRawCommentText( configuration.getText("doclet.enum_values_doc", classDoc.name())); } else if (currentMethod.name().equals("valueOf") && currentMethod.parameters().length == 1) { Type paramType = currentMethod.parameters()[0].type(); if (paramType != null && paramType.qualifiedTypeName().equals(String.class.getName())) { currentMethod.setRawCommentText( configuration.getText("doclet.enum_valueof_doc")); } } } }
public static Method getMethodByDoc(Class<?> classz, MethodDoc methodDoc) throws Exception { Class<?>[] parameterTypes = new Class<?>[methodDoc.parameters().length]; for (int i = 0; i < methodDoc.parameters().length; i++) { Parameter parameter = methodDoc.parameters()[i]; if (parameter.type().isPrimitive()) { if (parameter.type().simpleTypeName().equals("byte")) parameterTypes[i] = byte.class; else if (parameter.type().simpleTypeName().equals("boolean")) parameterTypes[i] = boolean.class; else if (parameter.type().simpleTypeName().equals("short")) parameterTypes[i] = short.class; else if (parameter.type().simpleTypeName().equals("char")) parameterTypes[i] = char.class; else if (parameter.type().simpleTypeName().equals("int")) parameterTypes[i] = int.class; else if (parameter.type().simpleTypeName().equals("long")) parameterTypes[i] = long.class; else if (parameter.type().simpleTypeName().equals("float")) parameterTypes[i] = float.class; else if (parameter.type().simpleTypeName().equals("double")) parameterTypes[i] = double.class; } else { parameterTypes[i] = Class.forName(parameter.type().qualifiedTypeName()); } if (!StringUtils.isEmpty(parameter.type().dimension())) { int dimension = StringUtil.getStrCount(parameter.type().dimension(), "[]"); parameterTypes[i] = Array.newInstance(parameterTypes[i], (int[])Array.newInstance(int.class, dimension)).getClass(); } } return classz.getDeclaredMethod(methodDoc.name(), parameterTypes); }
public static boolean start(RootDoc root) throws IOException { String dumpFileName = readOptions(root.options()); OutputStream os = Files.newOutputStream(Paths.get(dumpFileName)); Properties javaDocMap = new Properties(); for (ClassDoc classDoc : root.classes()) { javaDocMap.put(classDoc.toString(), classDoc.commentText()); for (MethodDoc method : classDoc.methods()) { javaDocMap.put(method.qualifiedName(), method.commentText()); for (ParamTag paramTag : method.paramTags()) { Parameter[] parameters = method.parameters(); for (int i = 0; i < parameters.length; ++i) { if (parameters[i].name().equals(paramTag.parameterName())) { javaDocMap.put(method.qualifiedName() + ".paramCommentTag." + i, paramTag.parameterComment()); } } } Tag[] retTags = method.tags("return"); if (retTags != null && retTags.length == 1) { Tag retTag = method.tags("return")[0]; javaDocMap.put(method.qualifiedName() + "." + "returnCommentTag", retTag.text()); } } } javaDocMap.store(os, ""); os.flush(); os.close(); return true; }
MethodDoc method2 = (MethodDoc) member2; if (method1.isStatic() && method2.isStatic()) { Parameter[] targetParams = method1.parameters(); Parameter[] currentParams; if (method1.name().equals(method2.name()) && (currentParams = method2.parameters()).length == targetParams.length) { int j;
/** Print the class's operations m */ private boolean operations(Options opt, MethodDoc m[]) { boolean printed = false; for (MethodDoc md : m) { if (hidden(md)) continue; // Filter-out static initializer method if (md.name().equals("<clinit>") && md.isStatic() && md.isPackagePrivate()) continue; stereotype(opt, md, Align.LEFT); String op = visibility(opt, md) + md.name() + // (opt.showType ? "(" + parameter(opt, md.parameters()) + ")" + typeAnnotation(opt, md.returnType()) : "()"); tableLine(Align.LEFT, (md.isAbstract() ? Font.ABSTRACT : Font.NORMAL).wrap(opt, op)); printed = true; tagvalue(opt, md); } return printed; }
/** Print the class's operations m */ private boolean operations(Options opt, MethodDoc m[]) { boolean printed = false; for (MethodDoc md : m) { if (hidden(md)) continue; // Filter-out static initializer method if (md.name().equals("<clinit>") && md.isStatic() && md.isPackagePrivate()) continue; stereotype(opt, md, Align.LEFT); String op = visibility(opt, md) + md.name(); if (opt.showType) { op += "(" + parameter(opt, md.parameters()) + ")" + typeAnnotation(opt, md.returnType()); } else { op += "()"; } tableLine(Align.LEFT, op, opt, md.isAbstract() ? Font.ABSTRACT : Font.NORMAL); printed = true; tagvalue(opt, md); } return printed; }
methodNode.setReturn(parseTypeInfo(methodDoc.returnType())); for (Parameter parameter : methodDoc.parameters()) { methodNode.getParameter().add(parseMethodParameter(parameter));
protected void printMarkDown(MethodDoc method) throws IOException { appendNewline("## `.%s(%s)`", method.name(), parameters(method.parameters())); appendNewline(); appendNewline(asMarkdown(method.commentText())); appendNewline(); if (method.paramTags().length > 0) { appendNewline("Parameter | Description"); appendNewline("--------- | -----------"); for (ParamTag param : method.paramTags()) { appendNewline("%s | %s", param.parameterName(), asMarkdown(param.parameterComment())); } appendNewline(); } for (Tag t : method.tags("return")) { String text = t.text(); if (text != null) { appendNewline("- **returns:** %s", asMarkdown(text)); } } for (Tag t : method.tags("see")) { String text = t.text(); if (text != null) { appendNewline("- **see:** %s", asMarkdown(text)); } } appendNewline(); }