public static PackageInfo[] chooseModulePackages() {
ClassInfo[] classes = Converter.rootClasses();
SortedMap<String, PackageInfo> sorted = new TreeMap<String, PackageInfo>();
for (ClassInfo cl : classes) {
if (!cl.isModule()) {
continue;
}
PackageInfo pkg = cl.containingPackage();
String name;
if (pkg == null) {
name = "";
} else {
name = pkg.name();
}
sorted.put(name, pkg);
}
ArrayList<PackageInfo> result = new ArrayList<PackageInfo>();
for (String s : sorted.keySet()) {
PackageInfo pkg = sorted.get(s);
result.add(pkg);
}
return result.toArray(new PackageInfo[result.size()]);
}
public static void writeHierarchy() {
ClassInfo[] classes = Converter.rootClasses();
ArrayList<ClassInfo> info = new ArrayList<ClassInfo>();
for (ClassInfo cl : classes) {
if (!cl.isHidden()) {
info.add(cl);
}
}
Data data = makePackageHDF();
Hierarchy.makeHierarchy(data, info.toArray(new ClassInfo[info.size()]));
setPageTitle(data, "Class Hierarchy");
ClearPage.write(data, "hierarchy.cs", javadocDir + "hierarchy" + htmlExtension);
}
public static void writeLists() {
Data data = makeHDF();
ClassInfo[] classes = Converter.rootClasses();
SortedMap<String, Object> sorted = new TreeMap<String, Object>();
for (ClassInfo cl : classes) {
if (cl.isHidden()) {
continue;
}
sorted.put(cl.qualifiedName(), cl);
PackageInfo pkg = cl.containingPackage();
String name;
if (pkg == null) {
name = "";
} else {
name = pkg.name();
}
sorted.put(name, pkg);
for (MethodInfo method : cl.methods()) {
if (method.isProcessor() || method.isSource() || method.isTransformer()) {
sorted.put(method.elementName(), method);
}
}
}
int i = 0;
for (String s : sorted.keySet()) {
data.setValue("docs.pages." + i + ".id", "" + i);
data.setValue("docs.pages." + i + ".label", s);
Object o = sorted.get(s);
if (o instanceof PackageInfo) {
PackageInfo pkg = (PackageInfo) o;
data.setValue("docs.pages." + i + ".link", "java/" + pkg.htmlPage());
data.setValue("docs.pages." + i + ".type", "package");
} else if (o instanceof ClassInfo) {
ClassInfo cl = (ClassInfo) o;
data.setValue("docs.pages." + i + ".link", "java/" + cl.htmlPage());
data.setValue("docs.pages." + i + ".type", "class");
} else if (o instanceof MethodInfo) {
MethodInfo mi = (MethodInfo) o;
data.setValue("docs.pages." + i + ".id", "" + i);
data.setValue("docs.pages." + i + ".link", "mule/" + mi.relativeModulePath());
data.setValue("docs.pages." + i + ".type", "method");
}
i++;
}
ClearPage.write(data, "lists.cs", javadocDir + "lists.js");
}
public static Data makeHDF() {
Data data = jSilver.createData();
for (String[] p : mHDFData) {
data.setValue(p[0], p[1]);
}
data.setValue("tabs.0.id", "guide");
data.setValue("tabs.0.title", "Install Guide");
data.setValue("tabs.0.link", guideDir + "install.html");
int i = 0;
for (String[] p : mMarkdown) {
i++;
data.setValue("tabs." + i + ".id", p[0]);
data.setValue("tabs." + i + ".title", p[2]);
String outFile = FilenameUtils.getName(p[1]).replaceAll(".md", ".html").toLowerCase();
data.setValue("tabs." + i + ".link", outFile);
}
i++;
data.setValue("tabs." + i + ".id", "java");
data.setValue("tabs." + i + ".title", "Java API Reference");
data.setValue("tabs." + i + ".link", javadocDir + "packages.html");
boolean hasModules = false;
ClassInfo[] classes = Converter.rootClasses();
for (ClassInfo cl : classes) {
if (cl.isModule()) {
hasModules = true;
}
}
if (hasModules) {
i++;
data.setValue("tabs." + i + ".id", "mule");
data.setValue("tabs." + i + ".title", "Mule API Reference");
data.setValue("tabs." + i + ".link", muleXmlDir + "modules.html");
}
return data;
}
public static void writeClasses() {
ClassInfo[] classes = Converter.rootClasses();
if (generateSources) {
mHDFData.add(new String[] {"doclava.generate.sources", "true"});
for (ClassInfo cl : classes) {
Data data = makePackageHDF();
if (!cl.isHidden()) {
writeSource(cl, data);
writeClass(cl, data);
}
}
} else {
for (ClassInfo cl : classes) {
Data data = makePackageHDF();
if (!cl.isHidden()) {
writeClass(cl, data);
}
}
}
}
public static PackageInfo[] choosePackages() {
if (sVisiblePackages != null) {
return sVisiblePackages;
}
ClassInfo[] classes = Converter.rootClasses();
SortedMap<String, PackageInfo> sorted = new TreeMap<String, PackageInfo>();
for (ClassInfo cl : classes) {
PackageInfo pkg = cl.containingPackage();
String name;
if (pkg == null) {
name = "";
} else {
name = pkg.name();
}
sorted.put(name, pkg);
}
ArrayList<PackageInfo> result = new ArrayList<PackageInfo>();
for (String s : sorted.keySet()) {
PackageInfo pkg = sorted.get(s);
if (pkg.isHidden()) {
continue;
}
Boolean allHidden = true;
int pass = 0;
ClassInfo[] classesToCheck = null;
while (pass < 5) {
switch (pass) {
case 0:
classesToCheck = pkg.ordinaryClasses();
break;
case 1:
classesToCheck = pkg.enums();
break;
case 2:
classesToCheck = pkg.errors();
break;
case 3:
classesToCheck = pkg.exceptions();
break;
case 4:
classesToCheck = pkg.getInterfaces();
break;
default:
System.err.println("Error reading package: " + pkg.name());
break;
}
for (ClassInfo cl : classesToCheck) {
if (!cl.isHidden()) {
allHidden = false;
break;
}
}
if (!allHidden) {
break;
}
pass++;
}
if (allHidden) {
continue;
}
result.add(pkg);
}
sVisiblePackages = result.toArray(new PackageInfo[result.size()]);
return sVisiblePackages;
}
public static Data makePackageHDF() {
Data data = makeHDF();
ClassInfo[] classes = Converter.rootClasses();
SortedMap<String, PackageInfo> sorted = new TreeMap<String, PackageInfo>();
for (ClassInfo cl : classes) {
PackageInfo pkg = cl.containingPackage();
String name;
if (pkg == null) {
name = "";
} else {
name = pkg.name();
}
sorted.put(name, pkg);
}
int i = 0;
for (String s : sorted.keySet()) {
PackageInfo pkg = sorted.get(s);
if (pkg.isHidden()) {
continue;
}
Boolean allHidden = true;
int pass = 0;
ClassInfo[] classesToCheck = null;
while (pass < 5) {
switch (pass) {
case 0:
classesToCheck = pkg.ordinaryClasses();
break;
case 1:
classesToCheck = pkg.enums();
break;
case 2:
classesToCheck = pkg.errors();
break;
case 3:
classesToCheck = pkg.exceptions();
break;
case 4:
classesToCheck = pkg.getInterfaces();
break;
default:
System.err.println("Error reading package: " + pkg.name());
break;
}
for (ClassInfo cl : classesToCheck) {
if (!cl.isHidden()) {
allHidden = false;
break;
}
}
if (!allHidden) {
break;
}
pass++;
}
if (allHidden) {
continue;
}
data.setValue("reference", "1");
data.setValue("reference.apilevels", sinceTagger.hasVersions() ? "1" : "0");
data.setValue("docs.packages." + i + ".name", s);
data.setValue("docs.packages." + i + ".link", pkg.htmlPage());
data.setValue("docs.packages." + i + ".since.key", SinceTagger.keyForName(pkg.getSince()));
data.setValue("docs.packages." + i + ".since.name", pkg.getSince());
TagInfo.makeHDF(data, "docs.packages." + i + ".shortDescr", pkg.firstSentenceTags());
i++;
}
sinceTagger.writeVersionNames(data);
return data;
}
public static boolean start(RootDoc r) {
String keepListFile = null;
String proofreadFile = null;
String todoFile = null;
String stubsDir = null;
// Create the dependency graph for the stubs directory
String apiFile = null;
HashSet<String> stubPackages = null;
ArrayList<String> knownTagsFiles = new ArrayList<String>();
root = r;
String[][] options = r.options();
for (String[] a : options) {
if (a[0].equals("-d")) {
ClearPage.outputDir = a[1];
} else if (a[0].equals("-templatedir")) {
ClearPage.addTemplateDir(a[1]);
} else if (a[0].equals("-hdf")) {
mHDFData.add(new String[] {a[1], a[2]});
} else if (a[0].equals("-markdown")) {
mMarkdown.add(new String[] {a[1], a[2], a[3]});
} else if (a[0].equals("-knowntags")) {
knownTagsFiles.add(a[1]);
} else if (a[0].equals("-toroot")) {
ClearPage.toroot = a[1];
} else if (a[0].equals("-title")) {
Doclava.title = a[1];
} else if (a[0].equals("-werror")) {
Errors.setWarningsAreErrors(true);
} else if (a[0].equals("-error") || a[0].equals("-warning") || a[0].equals("-hide")) {
try {
int level = -1;
if (a[0].equals("-error")) {
level = Errors.ERROR;
} else if (a[0].equals("-warning")) {
level = Errors.WARNING;
} else if (a[0].equals("-hide")) {
level = Errors.HIDDEN;
}
Errors.setErrorLevel(Integer.parseInt(a[1]), level);
} catch (NumberFormatException e) {
// already printed below
return false;
}
} else if (a[0].equals("-keeplist")) {
keepListFile = a[1];
} else if (a[0].equals("-proofread")) {
proofreadFile = a[1];
} else if (a[0].equals("-todo")) {
todoFile = a[1];
} else if (a[0].equals("-public")) {
showLevel = SHOW_PUBLIC;
} else if (a[0].equals("-protected")) {
showLevel = SHOW_PROTECTED;
} else if (a[0].equals("-package")) {
showLevel = SHOW_PACKAGE;
} else if (a[0].equals("-private")) {
showLevel = SHOW_PRIVATE;
} else if (a[0].equals("-hidden")) {
showLevel = SHOW_HIDDEN;
} else if (a[0].equals("-stubs")) {
stubsDir = a[1];
} else if (a[0].equals("-stubpackages")) {
stubPackages = new HashSet<String>();
for (String pkg : a[1].split(":")) {
stubPackages.add(pkg);
}
} else if (a[0].equals("-apixml")) {
apiFile = a[1];
} else if (a[0].equals("-nodocs")) {
generateDocs = false;
} else if (a[0].equals("-parsecomments")) {
parseComments = true;
} else if (a[0].equals("-since")) {
sinceTagger.addVersion(a[1], a[2]);
} else if (a[0].equals("-federate")) {
try {
String name = a[1];
URL federationURL = new URL(a[2]);
federationTagger.addSiteUrl(name, federationURL);
} catch (MalformedURLException e) {
System.err.println("Could not parse URL for federation: " + a[1]);
return false;
}
} else if (a[0].equals("-federationxml")) {
String name = a[1];
String file = a[2];
federationTagger.addSiteXml(name, file);
} else if (a[0].equals("-apiversion")) {
apiVersion = a[1];
} else if (a[0].equals("-assetsdir")) {
assetsOutputDir = a[1];
} else if (a[0].equals("-generatesources")) {
generateSources = true;
}
}
if (!readKnownTagsFiles(knownTags, knownTagsFiles)) {
return false;
}
// Set up the data structures
Converter.makeInfo(r);
// Stubs and xml
final File currentApiFile;
if (!generateDocs && apiFile != null) {
currentApiFile = new File(apiFile);
} else if (generateDocs) {
currentApiFile =
new File(ensureSlash(ClearPage.outputDir) + javadocDir + FederatedSite.XML_API_PATH);
} else {
currentApiFile = null;
}
Stubs.writeStubsAndXml(stubsDir, currentApiFile, stubPackages);
if (generateDocs && apiFile != null) {
ClearPage.copyFile(currentApiFile, new File(apiFile));
}
// Reference documentation
if (generateDocs) {
ClearPage.addBundledTemplateDir("assets/customizations");
ClearPage.addBundledTemplateDir("assets/templates");
List<ResourceLoader> resourceLoaders = new ArrayList<ResourceLoader>();
List<String> templates = ClearPage.getTemplateDirs();
for (String tmpl : templates) {
resourceLoaders.add(new FileSystemResourceLoader(tmpl));
}
templates = ClearPage.getBundledTemplateDirs();
for (String tmpl : templates) {
resourceLoaders.add(new ClassResourceLoader(Doclava.class, '/' + tmpl));
}
ResourceLoader compositeResourceLoader = new CompositeResourceLoader(resourceLoaders);
jSilver = new JSilver(compositeResourceLoader);
if (!Doclava.readTemplateSettings()) {
return false;
}
long startTime = System.nanoTime();
// Use current version information
if (apiVersion != null && sinceTagger.hasVersions()) {
sinceTagger.addVersion(currentApiFile.getAbsolutePath(), apiVersion);
}
// Apply @since tags from the XML file
sinceTagger.tagAll(Converter.rootClasses());
// Apply details of federated documentation
federationTagger.tagAll(Converter.rootClasses());
// Files for proofreading
if (proofreadFile != null) {
Proofread.initProofread(proofreadFile);
}
if (todoFile != null) {
TodoFile.writeTodoFile(todoFile);
}
writeAssets();
// Navigation tree
NavTree.writeNavTree(assetsOutputDir);
// Write Markdown files
writeMarkdowns();
// Mule
writeModules(muleXmlDir + "modules" + htmlExtension);
// Packages Pages
writePackages(javadocDir + "packages" + htmlExtension);
// Classes
writeClassLists();
writeClasses();
writeHierarchy();
// writeKeywords();
// Lists for JavaScript
writeLists();
if (keepListFile != null) {
writeKeepList(keepListFile);
}
// Index page
writeIndex();
// Installation page
writeInstall();
Proofread.finishProofread(proofreadFile);
long time = System.nanoTime() - startTime;
System.out.println(
"Mule DevKit took "
+ (time / 1000000000)
+ " sec. to write docs to "
+ ClearPage.outputDir);
}
Errors.printErrors();
return !Errors.hadError;
}
