public static boolean start(RootDoc root) { ClassDoc[] classDocs = root.classes(); if (ArrayUtils.isNotEmpty(classDocs)) { for (ClassDoc classDoc : root.classes()) scanClassDoc(result.docs, classDoc); } return true; }
/** * Builds the views according to the parameters on the command line * * @param opt The options * @param srcRootDoc The RootDoc for the source classes * @param viewRootDoc The RootDoc for the view classes (may be different, or may be the same as * the srcRootDoc) */ public static View[] buildViews(Options opt, RootDoc srcRootDoc, RootDoc viewRootDoc) { if (opt.viewName != null) { ClassDoc viewClass = viewRootDoc.classNamed(opt.viewName); if (viewClass == null) { System.out.println( "View " + opt.viewName + " not found! Exiting without generating any output."); return null; } if (viewClass.tags("view").length == 0) { System.out.println(viewClass + " is not a view!"); return null; } if (viewClass.isAbstract()) { System.out.println(viewClass + " is an abstract view, no output will be generated!"); return null; } return new View[] {buildView(srcRootDoc, viewClass, opt)}; } else if (opt.findViews) { List<View> views = new ArrayList<View>(); ClassDoc[] classes = viewRootDoc.classes(); // find view classes for (int i = 0; i < classes.length; i++) if (classes[i].tags("view").length > 0 && !classes[i].isAbstract()) views.add(buildView(srcRootDoc, classes[i], opt)); return views.toArray(new View[views.size()]); } else return new View[0]; }
public void process(RootDoc root) { final ClassDoc[] classes = root.classes(); for (ClassDoc clss : classes) { if (isBusinessMeaningful(clss)) { process(clss); } } }
public static void writeClassLists() { int i; Data data = makePackageHDF(); ClassInfo[] classes = PackageInfo.filterHidden(Converter.convertClasses(root.classes())); if (classes.length == 0) { return; } Sorter[] sorted = new Sorter[classes.length]; for (i = 0; i < sorted.length; i++) { ClassInfo cl = classes[i]; String name = cl.name(); sorted[i] = new Sorter(name, cl); } Arrays.sort(sorted); // make a pass and resolve ones that have the same name int firstMatch = 0; String lastName = sorted[0].label; for (i = 1; i < sorted.length; i++) { String s = sorted[i].label; if (!lastName.equals(s)) { if (firstMatch != i - 1) { // there were duplicates for (int j = firstMatch; j < i; j++) { PackageInfo pkg = ((ClassInfo) sorted[j].data).containingPackage(); if (pkg != null) { sorted[j].label = sorted[j].label + " (" + pkg.name() + ")"; } } } firstMatch = i; lastName = s; } } // and sort again Arrays.sort(sorted); for (i = 0; i < sorted.length; i++) { String s = sorted[i].label; ClassInfo cl = (ClassInfo) sorted[i].data; char first = Character.toUpperCase(s.charAt(0)); cl.makeShortDescrHDF(data, "docs.classes." + first + '.' + i); } setPageTitle(data, "Class Index"); ClearPage.write(data, "classes.cs", javadocDir + "classes" + htmlExtension); }
public List<StepClassDoc> filterStepClassDocs() throws QuoteTailNotFoundException { List<StepClassDoc> stepClassDocs = new ArrayList<StepClassDoc>(); int classId = 1; for (ClassDoc classDoc : rootDoc.classes()) { if (isCandidateClassDoc(classDoc)) { StepClassDoc stepClassDoc = new StepClassDoc(classId, classDoc); if (stepClassDoc.isStepClassDoc()) { rootDoc.printNotice("Step class found: " + classDoc); stepClassDocs.add(stepClassDoc); classId++; } } } return stepClassDocs; }
/** Builds and outputs a single graph according to the view overrides */ public static void buildGraph(RootDoc root, OptionProvider op, Doc contextDoc) throws IOException { if (getCommentOptions() == null) buildOptions(root); Options opt = op.getGlobalOptions(); root.printNotice("Building " + op.getDisplayName()); ClassDoc[] classes = root.classes(); ClassGraph c = new ClassGraph(root, op, contextDoc); c.prologue(); for (int i = 0; i < classes.length; i++) c.printClass(classes[i], true); for (int i = 0; i < classes.length; i++) c.printRelations(classes[i]); if (opt.inferRelationships) c.printInferredRelations(classes); if (opt.inferDependencies) c.printInferredDependencies(classes); c.printExtraClasses(root); c.epilogue(); }
public static boolean start(RootDoc root) { try { init(root); ClassDoc[] classes = root.classes(); ArrayList<String> generatesTestClasses = new ArrayList<String>(); for (int i = 0; i < classes.length; i++) { ClassDoc classDoc = classes[i]; if (classDoc.isAbstract() || classDoc.isInterface() || classDoc.isEnum() || classDoc.isPrivate() || classDoc.isAnnotationType()) { } else if (!hasDefaultConstructor(classDoc)) { System.out.println(classDoc.qualifiedTypeName() + " does not have default Constructor."); } else { ClassBean testClassBean = ClassBeanCreator.create(classDoc); if (testClassBean.hasMethods()) { JavaCodeWriter writer = getWriter(testClassBean); if (writer != null) { JavaCodeGenerator.generate(testClassBean, writer); generatesTestClasses.add(classDoc.qualifiedTypeName()); writer.close(); } } else { System.out.println( classDoc.qualifiedTypeName() + " does not have any methods to cover."); } } } System.out.println("---------REPORT-----------------------------------------------"); for (Iterator iterator = generatesTestClasses.iterator(); iterator.hasNext(); ) { String clsName = (String) iterator.next(); System.out.println("\t" + clsName); } System.out.println("-------------------------------------------------------------"); return true; } catch (Exception e) { e.printStackTrace(); return false; } }
private static void generateText(RootDoc root) throws IOException { List<RestMethod> methods = new ArrayList<RestMethod>(); for (ClassDoc classDoc : root.classes()) { for (MethodDoc methodDoc : classDoc.methods()) { if (methodDoc.isPublic()) { methods.add(new RestMethod(methodDoc)); } } } FileWriter jsonFile = null; try { jsonFile = new FileWriter(outputDir + "/candlepin_comments.json"); mapper.writeValue(jsonFile, methods); } finally { jsonFile.close(); } }
/** * The entry point for processing provides an object to access the various attributes of all the * classes being documented. * * @param rootDoc the root of the documentation tree * @return some boolean value */ public static boolean start(RootDoc rootDoc) { ClassDoc[] classes; Iterator i = null; readConfig(); my_initialize(); classes = rootDoc.classes(); i = m_pipeline.values().iterator(); while (i.hasNext()) { tool = (FeatureTool) i.next(); for (int i = 0; i < classes.length; i++) { m_commentQualityRecords.add(tool.process(classes[i])); } } // correlate/aggregate quality reports // display quality reports return true; }
private void startGeneration(RootDoc root) throws Exception { if (root.classes().length == 0) { configuration.message.error("doclet.No_Public_Classes_To_Document"); return; } configuration.setOptions(); configuration .getDocletSpecificMsg() .notice("doclet.build_version", configuration.getDocletSpecificBuildDate()); configuration.tagletManager.addCustomTag(new SequenceDiagramTag()); configuration.tagletManager.addCustomTag(new DotDiagramTag()); configuration.tagletManager.addNewSimpleCustomTag("ArchitectureDocument", "", "X"); ClassTree classtree = new ClassTree(configuration, configuration.nodeprecated); generateClassFiles(root, classtree); if (configuration.sourcepath != null && configuration.sourcepath.length() > 0) { StringTokenizer pathTokens = new StringTokenizer(configuration.sourcepath, String.valueOf(File.pathSeparatorChar)); boolean first = true; while (pathTokens.hasMoreTokens()) { Util.copyDocFiles( configuration, pathTokens.nextToken() + File.separator, DocletConstants.DOC_FILES_DIR_NAME, first); first = false; } } PackageListWriter.generate(configuration); generatePackageFiles(classtree); generateOtherFiles(root, classtree); configuration.tagletManager.printReport(); }
/** @throws Exception . */ public void run() throws Exception { // GENERATE DOCUMENTATIONS IN DOC CLASSES ClassDoc[] classes = documentation.classes(); List<DocController> controllers = generateControllers(classes); logger.log( Level.INFO, "Generated " + controllers.size() + " controlles, creating HTML documentation using velocity template."); // TRANSLATE DOC CLASSES INTO HTML DOCUMENTATION USING VELOCITY TEMPLATE String generatedHtml = generateHtmlDocumentation(controllers); // WRITE GENERATED HTML TO A FILE FileWriter velocityfileWriter = null; try { File file = new File(docPath); File parentFile = file.getParentFile(); if (parentFile != null) { if (parentFile.mkdirs()) { logger.log( Level.FINEST, "The directory " + parentFile.getAbsolutePath() + " was created, along with all necessary parent directories."); } } logger.log(Level.INFO, "Write generated velocity to " + file.getAbsolutePath()); velocityfileWriter = new FileWriter(file); velocityfileWriter.write(generatedHtml); } finally { if (velocityfileWriter != null) { velocityfileWriter.close(); } } }
/** * Create a new ClassGraph. * * <p>The packages passed as an argument are the ones specified on the command line. * * <p>Local URLs will be generated for these packages. * * @param root The root of docs as provided by the javadoc API * @param optionProvider The main option provider * @param contextDoc The current context for generating relative links, may be a ClassDoc or a * PackageDoc (used by UMLDoc) */ public ClassGraph(RootDoc root, OptionProvider optionProvider, Doc contextDoc) { this.optionProvider = optionProvider; this.collectionClassDoc = root.classNamed("java.util.Collection"); this.mapClassDoc = root.classNamed("java.util.Map"); this.contextDoc = contextDoc; // to gather the packages containing specified classes, loop thru them and gather // package definitions. User root.specifiedPackages is not safe, since the user // may specify just a list of classes (human users usually don't, but automated tools do) rootClasses = new HashSet<String>(); for (ClassDoc classDoc : root.classes()) { rootClasses.add(classDoc.qualifiedName()); rootClassdocs.put(classDoc.qualifiedName(), classDoc); } Options opt = optionProvider.getGlobalOptions(); if (opt.compact) { linePrefix = ""; linePostfix = ""; } else { linePrefix = "\t"; linePostfix = "\n"; } }
/** Return the ClassDoc for the specified class; null if not found. */ private static ClassDoc findClass(RootDoc root, String name) { ClassDoc[] classes = root.classes(); for (ClassDoc cd : classes) if (cd.name().equals(name)) return cd; return null; }
public static boolean start(RootDoc root) { ClassDoc cd = root.classes()[0]; FieldDoc fd = cd.fields()[0]; fd.firstSentenceTags(); return true; }
public static boolean start(com.sun.javadoc.RootDoc root) { ClassDoc[] classes = root.classes(); if (classes.length != 1) throw new Error("1 " + Arrays.asList(classes)); return true; }
/** * Constructor. Build the Tree using the Root of this Javadoc run. * * @param root Root of the Document. * @param configuration The curren configuration of the doclet. */ public ClassTree(RootDoc root, Configuration configuration) { buildTree(root.classes(), configuration); }
/** * The entry point into the Parser class. * * @param root A RootDoc intstance obtained via the doclet API * @return A XML (XStream) serializable element, containing everything parsed from javadoc doclet */ public static Root ParseRoot(RootDoc root) { processingStorage = new HashMap<PackageDoc, ParserMediary>(); try { md5 = MessageDigest.getInstance("MD5"); } catch (NoSuchAlgorithmException e) { log.error("unable to acquire MD5 algorithm", e); return null; } rootXml = new Root(); ClassDoc[] allClasses = root.classes(); for (ClassDoc classDoc : allClasses) { PackageDoc doc = classDoc.containingPackage(); ParserMediary mediary = null; // the age old 'if I have it pull out existing, if I don't make a new one' if (processingStorage.containsKey(doc)) { mediary = processingStorage.get(doc); } else { mediary = new ParserMediary( doc.name(), doc.commentText(), ParseAnnotationInstances(doc.annotations(), doc.name())); processingStorage.put(doc, mediary); } if (classDoc.isIncluded()) { // dev comment--why do enums show up as ordinary class? if (classDoc.isOrdinaryClass() || classDoc.isException() || classDoc.isError()) { mediary.addClass(ParseClass(classDoc)); } else if (classDoc.isEnum()) { mediary.addEnum(ParseEnum(classDoc)); } else if (isAnnotation(classDoc)) { mediary.addAnnotation(ParseAnnotation(classDoc)); } else if (classDoc.isInterface()) { mediary.addInterface(ParseInterface(classDoc)); } } else { log.debug("Skipping not-included class " + classDoc.qualifiedName()); } } if (processingStorage.size() > 0) { List list = new ArrayList<Package>(); for (ParserMediary mediary : processingStorage.values()) { list.add(mediary.wrapup()); } rootXml.packages = (Package[]) list.toArray(new Package[] {}); } else { log.warn("No packages found!"); } return rootXml; }