/*
|
* Copyright 2011 gitblit.com.
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
package com.gitblit.build;
|
|
import java.io.BufferedReader;
|
import java.io.File;
|
import java.io.FileOutputStream;
|
import java.io.FileReader;
|
import java.io.FilenameFilter;
|
import java.io.OutputStreamWriter;
|
import java.nio.charset.Charset;
|
import java.text.MessageFormat;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Vector;
|
|
import com.beust.jcommander.JCommander;
|
import com.beust.jcommander.Parameter;
|
import com.beust.jcommander.ParameterException;
|
import com.beust.jcommander.Parameters;
|
import com.gitblit.Constants;
|
import com.gitblit.utils.FileUtils;
|
import com.gitblit.utils.MarkdownUtils;
|
import com.gitblit.utils.StringUtils;
|
|
/**
|
* Builds the web site or deployment documentation from Markdown source files.
|
*
|
* All Markdown source files must have the .mkd extension.
|
*
|
* Natural string sort order of the Markdown source filenames is the order of
|
* page links. "##_" prefixes are used to control the sort order.
|
*
|
* @author James Moger
|
*
|
*/
|
public class BuildSite {
|
|
private static final String SPACE_DELIMITED = "SPACE-DELIMITED";
|
|
private static final String CASE_SENSITIVE = "CASE-SENSITIVE";
|
|
private static final String RESTART_REQUIRED = "RESTART REQUIRED";
|
|
private static final String SINCE = "SINCE";
|
|
public static void main(String... args) {
|
Params params = new Params();
|
JCommander jc = new JCommander(params);
|
try {
|
jc.parse(args);
|
} catch (ParameterException t) {
|
usage(jc, t);
|
}
|
|
File sourceFolder = new File(params.sourceFolder);
|
File destinationFolder = new File(params.outputFolder);
|
File[] markdownFiles = sourceFolder.listFiles(new FilenameFilter() {
|
|
@Override
|
public boolean accept(File dir, String name) {
|
return name.toLowerCase().endsWith(".mkd");
|
}
|
});
|
Arrays.sort(markdownFiles);
|
|
Map<String, String> aliasMap = new HashMap<String, String>();
|
for (String alias : params.aliases) {
|
String[] values = alias.split("=");
|
aliasMap.put(values[0], values[1]);
|
}
|
|
System.out.println(MessageFormat.format("Generating site from {0} Markdown Docs in {1} ",
|
markdownFiles.length, sourceFolder.getAbsolutePath()));
|
|
String htmlHeader = FileUtils.readContent(new File(params.pageHeader), "\n");
|
|
String htmlAdSnippet = null;
|
if (!StringUtils.isEmpty(params.adSnippet)) {
|
File snippet = new File(params.adSnippet);
|
if (snippet.exists()) {
|
htmlAdSnippet = FileUtils.readContent(snippet, "\n");
|
}
|
}
|
String htmlFooter = FileUtils.readContent(new File(params.pageFooter), "\n");
|
final String date = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
|
final String footer = MessageFormat.format(htmlFooter, "generated " + date);
|
for (File file : markdownFiles) {
|
String documentName = getDocumentName(file);
|
if (params.skips.contains(documentName)) {
|
continue;
|
}
|
try {
|
String links = createLinks(file, markdownFiles, aliasMap, params.skips);
|
String header = MessageFormat.format(htmlHeader, Constants.FULL_NAME, links);
|
if (!StringUtils.isEmpty(params.analyticsSnippet)) {
|
File snippet = new File(params.analyticsSnippet);
|
if (snippet.exists()) {
|
String htmlSnippet = FileUtils.readContent(snippet, "\n");
|
header = header.replace("<!-- ANALYTICS -->", htmlSnippet);
|
}
|
}
|
|
String fileName = documentName + ".html";
|
System.out.println(MessageFormat.format(" {0} => {1}", file.getName(), fileName));
|
String rawContent = FileUtils.readContent(file, "\n");
|
String markdownContent = rawContent;
|
|
Map<String, List<String>> nomarkdownMap = new HashMap<String, List<String>>();
|
|
// extract sections marked as no-markdown
|
int nmd = 0;
|
for (String token : params.nomarkdown) {
|
StringBuilder strippedContent = new StringBuilder();
|
|
String nomarkdownKey = "%NOMARKDOWN" + nmd + "%";
|
String[] kv = token.split(":", 2);
|
String beginToken = kv[0];
|
String endToken = kv[1];
|
|
// strip nomarkdown chunks from markdown and cache them
|
List<String> chunks = new Vector<String>();
|
int beginCode = 0;
|
int endCode = 0;
|
while ((beginCode = markdownContent.indexOf(beginToken, endCode)) > -1) {
|
if (endCode == 0) {
|
strippedContent.append(markdownContent.substring(0, beginCode));
|
} else {
|
strippedContent.append(markdownContent.substring(endCode, beginCode));
|
}
|
strippedContent.append(nomarkdownKey);
|
endCode = markdownContent.indexOf(endToken, beginCode);
|
chunks.add(markdownContent.substring(beginCode, endCode));
|
nomarkdownMap.put(nomarkdownKey, chunks);
|
}
|
|
// get remainder of text
|
if (endCode < markdownContent.length()) {
|
strippedContent.append(markdownContent.substring(endCode,
|
markdownContent.length()));
|
}
|
markdownContent = strippedContent.toString();
|
nmd++;
|
}
|
|
// transform markdown to html
|
String content = transformMarkdown(markdownContent.toString());
|
|
// reinsert nomarkdown chunks
|
for (Map.Entry<String, List<String>> nomarkdown : nomarkdownMap.entrySet()) {
|
for (String chunk : nomarkdown.getValue()) {
|
content = content.replaceFirst(nomarkdown.getKey(), chunk);
|
}
|
}
|
|
for (String token : params.substitutions) {
|
String[] kv = token.split("=", 2);
|
content = content.replace(kv[0], kv[1]);
|
}
|
for (String token : params.regex) {
|
String[] kv = token.split("!!!", 2);
|
content = content.replaceAll(kv[0], kv[1]);
|
}
|
for (String alias : params.properties) {
|
String[] kv = alias.split("=", 2);
|
String loadedContent = generatePropertiesContent(new File(kv[1]));
|
content = content.replace(kv[0], loadedContent);
|
}
|
for (String alias : params.loads) {
|
String[] kv = alias.split("=", 2);
|
String loadedContent = FileUtils.readContent(new File(kv[1]), "\n");
|
loadedContent = StringUtils.escapeForHtml(loadedContent, false);
|
loadedContent = StringUtils.breakLinesForHtml(loadedContent);
|
content = content.replace(kv[0], loadedContent);
|
}
|
OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(new File(
|
destinationFolder, fileName)), Charset.forName("UTF-8"));
|
writer.write(header);
|
if (!StringUtils.isEmpty(htmlAdSnippet)) {
|
writer.write(htmlAdSnippet);
|
}
|
writer.write(content);
|
writer.write(footer);
|
writer.close();
|
} catch (Throwable t) {
|
System.err.println("Failed to transform " + file.getName());
|
t.printStackTrace();
|
}
|
}
|
}
|
|
private static String getDocumentName(File file) {
|
String displayName = file.getName().substring(0, file.getName().lastIndexOf('.'))
|
.toLowerCase();
|
int underscore = displayName.indexOf('_') + 1;
|
if (underscore > -1) {
|
// trim leading ##_ which is to control display order
|
return displayName.substring(underscore);
|
}
|
return displayName;
|
}
|
|
private static String createLinks(File currentFile, File[] markdownFiles,
|
Map<String, String> aliasMap, List<String> skips) {
|
String linkPattern = "<li><a href=''{0}''>{1}</a></li>";
|
String currentLinkPattern = "<li class=''active''><a href=''{0}''>{1}</a></li>";
|
StringBuilder sb = new StringBuilder();
|
for (File file : markdownFiles) {
|
String documentName = getDocumentName(file);
|
if (!skips.contains(documentName)) {
|
String displayName = documentName;
|
if (aliasMap.containsKey(documentName)) {
|
displayName = aliasMap.get(documentName);
|
} else {
|
displayName = displayName.replace('_', ' ');
|
}
|
String fileName = documentName + ".html";
|
if (currentFile.getName().equals(file.getName())) {
|
sb.append(MessageFormat.format(currentLinkPattern, fileName, displayName));
|
} else {
|
sb.append(MessageFormat.format(linkPattern, fileName, displayName));
|
}
|
}
|
}
|
sb.setLength(sb.length() - 3);
|
sb.trimToSize();
|
return sb.toString();
|
}
|
|
private static String generatePropertiesContent(File propertiesFile) throws Exception {
|
// Read the current Gitblit properties
|
BufferedReader propertiesReader = new BufferedReader(new FileReader(propertiesFile));
|
|
Vector<Setting> settings = new Vector<Setting>();
|
List<String> comments = new ArrayList<String>();
|
String line = null;
|
while ((line = propertiesReader.readLine()) != null) {
|
if (line.length() == 0) {
|
Setting s = new Setting("", "", comments);
|
settings.add(s);
|
comments.clear();
|
} else {
|
if (line.charAt(0) == '#') {
|
comments.add(line.substring(1).trim());
|
} else {
|
String[] kvp = line.split("=", 2);
|
String key = kvp[0].trim();
|
Setting s = new Setting(key, kvp[1].trim(), comments);
|
settings.add(s);
|
comments.clear();
|
}
|
}
|
}
|
propertiesReader.close();
|
|
StringBuilder sb = new StringBuilder();
|
for (Setting setting : settings) {
|
for (String comment : setting.comments) {
|
if (comment.contains(SINCE) || comment.contains(RESTART_REQUIRED)
|
|| comment.contains(CASE_SENSITIVE) || comment.contains(SPACE_DELIMITED)) {
|
sb.append(MessageFormat.format(
|
"<span style=\"color:#004000;\"># <i>{0}</i></span>",
|
transformMarkdown(comment)));
|
} else {
|
sb.append(MessageFormat.format("<span style=\"color:#004000;\"># {0}</span>",
|
transformMarkdown(comment)));
|
}
|
sb.append("<br/>\n");
|
}
|
if (!StringUtils.isEmpty(setting.name)) {
|
sb.append(MessageFormat
|
.format("<span style=\"color:#000080;\">{0}</span> = <span style=\"color:#800000;\">{1}</span>",
|
setting.name, StringUtils.escapeForHtml(setting.value, false)));
|
}
|
sb.append("<br/>\n");
|
}
|
|
return sb.toString();
|
}
|
|
private static String transformMarkdown(String comment) throws ParseException {
|
String md = MarkdownUtils.transformMarkdown(comment);
|
if (md.startsWith("<p>")) {
|
md = md.substring(3);
|
}
|
if (md.endsWith("</p>")) {
|
md = md.substring(0, md.length() - 4);
|
}
|
return md;
|
}
|
|
private static void usage(JCommander jc, ParameterException t) {
|
System.out.println(Constants.getGitBlitVersion());
|
System.out.println();
|
if (t != null) {
|
System.out.println(t.getMessage());
|
System.out.println();
|
}
|
if (jc != null) {
|
jc.usage();
|
}
|
System.exit(0);
|
}
|
|
/**
|
* Setting represents a setting with its comments from the properties file.
|
*/
|
private static class Setting {
|
final String name;
|
final String value;
|
final List<String> comments;
|
|
Setting(String name, String value, List<String> comments) {
|
this.name = name;
|
this.value = value;
|
this.comments = new ArrayList<String>(comments);
|
}
|
}
|
|
/**
|
* JCommander Parameters class for BuildSite.
|
*/
|
@Parameters(separators = " ")
|
private static class Params {
|
|
@Parameter(names = { "--sourceFolder" }, description = "Markdown Source Folder", required = true)
|
public String sourceFolder;
|
|
@Parameter(names = { "--outputFolder" }, description = "HTML Ouptut Folder", required = true)
|
public String outputFolder;
|
|
@Parameter(names = { "--pageHeader" }, description = "Page Header HTML Snippet", required = true)
|
public String pageHeader;
|
|
@Parameter(names = { "--pageFooter" }, description = "Page Footer HTML Snippet", required = true)
|
public String pageFooter;
|
|
@Parameter(names = { "--adSnippet" }, description = "Ad HTML Snippet", required = false)
|
public String adSnippet;
|
|
@Parameter(names = { "--analyticsSnippet" }, description = "Analytics HTML Snippet", required = false)
|
public String analyticsSnippet;
|
|
@Parameter(names = { "--skip" }, description = "Filename to skip", required = false)
|
public List<String> skips = new ArrayList<String>();
|
|
@Parameter(names = { "--alias" }, description = "Filename=Linkname aliases", required = false)
|
public List<String> aliases = new ArrayList<String>();
|
|
@Parameter(names = { "--substitute" }, description = "%TOKEN%=value", required = false)
|
public List<String> substitutions = new ArrayList<String>();
|
|
@Parameter(names = { "--load" }, description = "%TOKEN%=filename", required = false)
|
public List<String> loads = new ArrayList<String>();
|
|
@Parameter(names = { "--properties" }, description = "%TOKEN%=filename", required = false)
|
public List<String> properties = new ArrayList<String>();
|
|
@Parameter(names = { "--nomarkdown" }, description = "%STARTTOKEN%:%ENDTOKEN%", required = false)
|
public List<String> nomarkdown = new ArrayList<String>();
|
|
@Parameter(names = { "--regex" }, description = "searchPattern!!!replacePattern", required = false)
|
public List<String> regex = new ArrayList<String>();
|
|
}
|
}
|
