public static void writeModule(ClassInfo cl, Data data) {
cl.makeHDF(data);
setPageTitle(data, cl.name());
ClearPage.write(data, "module.cs", Doclava.muleXmlDir + cl.modulePath());
ClearPage.write(data, "schema.cs", Doclava.muleXmlDir + cl.moduleSchemaPath());
// Proofread.writeClass(cl.modulePath(), cl);
}
public static void writeAssets() {
JarFile thisJar = JarUtils.jarForClass(Doclava.class, null);
if (thisJar != null) {
try {
List<String> templateDirs = ClearPage.getBundledTemplateDirs();
for (String templateDir : templateDirs) {
String assetsDir = ensureSlash(templateDir) + "assets";
JarUtils.copyResourcesToDirectory(
thisJar, assetsDir, ensureSlash(ClearPage.outputDir) + assetsOutputDir);
}
// write mule-developer-core.css
Data data = makeHDF();
ClearPage.write(
data, "mule-developer-core.cs", assetsOutputDir + "/mule-developer-core.css");
} catch (IOException e) {
System.err.println("Error copying assets directory.");
e.printStackTrace();
return;
}
}
List<String> templateDirs = ClearPage.getTemplateDirs();
for (String templateDir : templateDirs) {
File assets = new File(ensureSlash(templateDir) + "assets");
if (assets.isDirectory()) {
writeDirectory(null, assets, assetsOutputDir, null, "");
}
}
}
public static void writeModules(String filename) {
Data data = makeHDF();
int i = 0;
for (PackageInfo pkg : chooseModulePackages()) {
data.setValue("reference", "1");
data.setValue("reference.apilevels", sinceTagger.hasVersions() ? "1" : "0");
data.setValue("docs.packages." + i + ".name", pkg.name());
makeModuleListHDF(data, "docs.packages." + i + ".modules", pkg.modules());
for (int j = 0; j < pkg.modules().length; j++) {
Data classData = makeHDF();
ClassInfo mod = pkg.modules()[j];
writeModule(mod, classData);
}
i++;
}
setPageTitle(data, "Module Index");
TagInfo.makeHDF(data, "root.descr", Converter.convertTags(root.inlineTags(), null));
ClearPage.write(data, "modules.cs", filename);
Proofread.writePackages(filename, Converter.convertTags(root.inlineTags(), null));
}
public static void writeClass(ClassInfo cl, Data data) {
cl.makeHDF(data);
setPageTitle(data, cl.name());
ClearPage.write(data, "class.cs", Doclava.javadocDir + cl.relativePath());
Proofread.writeClass(cl.htmlPage(), cl);
}
public static void writeSource(ClassInfo cl, Data data) {
try {
cl.makeHDF(data);
data.setValue("class.source", SampleTagInfo.escapeHtml(cl.getSource()));
setPageTitle(data, cl.name());
ClearPage.write(data, "source.cs", Doclava.javadocDir + cl.relativePath("-source"));
} catch (IOException e) {
Errors.error(Errors.IO_ERROR, null, "Could not find source file for " + cl.name());
}
}
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 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 static void writePackage(PackageInfo pkg) {
// these this and the description are in the same directory,
// so it's okay
Data data = makePackageHDF();
String name = pkg.name();
data.setValue("package.name", name);
data.setValue("package.since.key", SinceTagger.keyForName(pkg.getSince()));
data.setValue("package.since.name", pkg.getSince());
data.setValue("package.descr", "...description...");
pkg.setFederatedReferences(data, "package");
makeClassListHDF(data, "package.annotations", ClassInfo.sortByName(pkg.getAnnotations()));
makeClassListHDF(data, "package.interfaces", ClassInfo.sortByName(pkg.getInterfaces()));
makeClassListHDF(data, "package.classes", ClassInfo.sortByName(pkg.ordinaryClasses()));
makeClassListHDF(data, "package.modules", ClassInfo.sortByName(pkg.modules()));
makeClassListHDF(data, "package.enums", ClassInfo.sortByName(pkg.enums()));
makeClassListHDF(data, "package.exceptions", ClassInfo.sortByName(pkg.exceptions()));
makeClassListHDF(data, "package.errors", ClassInfo.sortByName(pkg.errors()));
TagInfo[] shortDescrTags = pkg.firstSentenceTags();
TagInfo[] longDescrTags = pkg.inlineTags();
TagInfo.makeHDF(data, "package.shortDescr", shortDescrTags);
TagInfo.makeHDF(data, "package.descr", longDescrTags);
data.setValue(
"package.hasLongDescr", TagInfo.tagsEqual(shortDescrTags, longDescrTags) ? "0" : "1");
String filename = Doclava.javadocDir + pkg.relativePath();
setPageTitle(data, name);
ClearPage.write(data, "package.cs", filename);
filename = javadocDir + pkg.fullDescriptionFile();
setPageTitle(data, name + " Details");
ClearPage.write(data, "package-descr.cs", filename);
Proofread.writePackage(filename, pkg.inlineTags());
}
public static void writePackages(String filename) {
Data data = makePackageHDF();
int i = 0;
for (PackageInfo pkg : choosePackages()) {
writePackage(pkg);
data.setValue("docs.packages." + i + ".name", pkg.name());
data.setValue("docs.packages." + i + ".link", pkg.htmlPage());
TagInfo.makeHDF(data, "docs.packages." + i + ".shortDescr", pkg.firstSentenceTags());
i++;
}
setPageTitle(data, "Package Index");
TagInfo.makeHDF(data, "root.descr", Converter.convertTags(root.inlineTags(), null));
ClearPage.write(data, "packages.cs", filename);
ClearPage.write(data, "package-list.cs", javadocDir + "package-list");
Proofread.writePackages(filename, Converter.convertTags(root.inlineTags(), null));
}
public static void writeMarkdowns() {
MarkdownProcessor markdown = new MarkdownProcessor();
for (String[] m : mMarkdown) {
try {
String mdContent = FileUtils.readFileToString(new File(m[1]));
String htmlContent = markdown.markdown(mdContent);
String outFile = FilenameUtils.getName(m[1]).replaceAll(".md", ".html").toLowerCase();
Data data = makeHDF();
data.setValue("content", htmlContent);
data.setValue("section", m[0]);
ClearPage.write(data, "markdown.cs", outFile);
} catch (IOException e) {
System.err.println("Cannot read " + m[1] + " file: " + e.getMessage());
}
}
}
private static void writeInstall() {
Data data = makeHDF();
ClearPage.write(data, "install.cs", guideDir + "install" + htmlExtension);
}
private static void writeIndex() {
Data data = makeHDF();
ClearPage.write(data, "index.cs", "index" + htmlExtension);
}
public static void writePage(String docfile, String relative, String outfile) {
HDF hdf = DroidDoc.makeHDF();
/*
System.out.println("docfile='" + docfile
+ "' relative='" + relative + "'"
+ "' outfile='" + outfile + "'");
*/
String filedata = readFile(docfile);
// The document is properties up until the line "@jd:body".
// Any blank lines are ignored.
int start = -1;
int lineno = 1;
Matcher lines = LINE.matcher(filedata);
String line = null;
while (lines.find()) {
line = lines.group(1);
if (line.length() > 0) {
if (line.equals("@jd:body")) {
start = lines.end();
break;
}
Matcher prop = PROP.matcher(line);
if (prop.matches()) {
String key = prop.group(1);
String value = prop.group(2);
hdf.setValue(key, value);
} else {
break;
}
}
lineno++;
}
if (start < 0) {
System.err.println(docfile + ":" + lineno + ": error parsing docfile");
if (line != null) {
System.err.println(docfile + ":" + lineno + ":" + line);
}
System.exit(1);
}
// if they asked to only be for a certain template, maybe skip it
String fromTemplate = hdf.getValue("template.which", "");
String fromPage = hdf.getValue("page.onlyfortemplate", "");
if (!"".equals(fromPage) && !fromTemplate.equals(fromPage)) {
return;
}
// and the actual text after that
String commentText = filedata.substring(start);
Comment comment = new Comment(commentText, null, new SourcePositionInfo(docfile, lineno, 1));
TagInfo[] tags = comment.tags();
TagInfo.makeHDF(hdf, "root.descr", tags);
hdf.setValue("commentText", commentText);
// write the page using the appropriate root template, based on the
// whichdoc value supplied by build
String fromWhichmodule = hdf.getValue("android.whichmodule", "");
if (fromWhichmodule.equals("online-pdk")) {
// leaving this in just for temporary compatibility with pdk doc
hdf.setValue("online-pdk", "true");
// add any conditional login for root template here (such as
// for custom left nav based on tab etc.
ClearPage.write(hdf, "docpage.cs", outfile);
} else {
if (outfile.indexOf("sdk/") != -1) {
hdf.setValue("sdk", "true");
if ((outfile.indexOf("index.html") != -1) || (outfile.indexOf("features.html") != -1)) {
ClearPage.write(hdf, "sdkpage.cs", outfile);
} else {
ClearPage.write(hdf, "docpage.cs", outfile);
}
} else if (outfile.indexOf("guide/") != -1) {
hdf.setValue("guide", "true");
ClearPage.write(hdf, "docpage.cs", outfile);
} else if (outfile.indexOf("resources/") != -1) {
hdf.setValue("resources", "true");
ClearPage.write(hdf, "docpage.cs", outfile);
} else {
ClearPage.write(hdf, "nosidenavpage.cs", outfile);
}
}
} // writePage
