blob: 1406cbb378b9f8abdb8afef1ac62682a25b8fd67 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 generator
import groovy.io.FileType
import groovy.text.markup.MarkupTemplateEngine
import groovy.text.markup.TemplateConfiguration
import groovy.transform.CompileDynamic
import groovy.transform.CompileStatic
import groovy.xml.StreamingMarkupBuilder
import groovy.xml.XmlUtil
import model.Changelog
import model.Page
import model.Section
import model.SectionItem
import model.SiteMap
import org.asciidoctor.Options
import org.asciidoctor.ast.Document
import java.nio.file.FileSystems
import java.nio.file.Path
import java.nio.file.WatchEvent
import static generator.DocumentationHTMLCleaner.parsePage
import static java.nio.file.StandardWatchEventKinds.*
@CompileStatic
class SiteGenerator {
private final static Closure SEMANTIC_SORT = { String v1, String v2 ->
List<String> items1 = decomposeVersion(v1)
List<String> items2 = decomposeVersion(v2)
for (int i=0; i<Math.max(items1.size(),items2.size());i++) {
if (i>=items2.size()) {
return 1
}
if (i>=items1.size()) {
return -1
}
def p1 = items1[i]
def p2 = items2[i]
if (p1.isNumber()) {
if (p2.isNumber()) {
def pi1 = p1.toInteger()
def pi2 = p2.toInteger()
if (pi1 < pi2) {
return 1
} else if (pi1 > pi2) {
return -1
}
} else {
return -1
}
} else if (p2.isNumber()) {
return 1
} else {
return p2 <=> p1
}
}
0
}
File sourcesDir
File outputDir
String sitemapFilename
private MarkupTemplateEngine tplEngine
private SiteMap siteMap
void setup() {
println "Generating website using Groovy ${GroovySystem.version}"
def tplConf = new TemplateConfiguration()
tplConf.autoIndent = true
tplConf.autoNewLine = true
tplConf.baseTemplateClass = PageTemplate
def classLoader = new URLClassLoader([sourcesDir.toURI().toURL()] as URL[], this.class.classLoader)
tplEngine = new MarkupTemplateEngine(classLoader, tplConf, new MarkupTemplateEngine.CachingTemplateResolver())
siteMap = SiteMap.from(new File(sourcesDir, sitemapFilename))
}
void render(String page, String target = null, Map model = [:], String baseDir=null) {
model.menu = siteMap.menu
model.currentPage = target
target = target ?: page
File root
if (baseDir) {
root = new File(outputDir, baseDir)
model[PageTemplate.BASEDIR] = baseDir
root.mkdirs()
} else {
root = outputDir
}
new File(root,"${target}.html").write(tplEngine.createTemplateByPath("pages/${page}.groovy").make(model).toString(), 'utf-8')
}
void generateSite() {
long sd = System.currentTimeMillis()
setup()
List<Changelog> changelogs = []
if (siteMap.changelogs) {
def cacheDir = new File(new File('build'), 'cache')
cacheDir.mkdirs()
println "Cache directory: $cacheDir"
changelogs = ChangelogParser.fetchReleaseNotes(cacheDir)
}
renderDocumentation()
renderPages(changelogs)
renderChangelogs(changelogs)
if (siteMap.releaseNotes) {
renderReleaseNotes()
}
if (siteMap.wiki) {
renderWiki()
}
if (siteMap.blog) {
renderBlog()
}
long dur = System.currentTimeMillis() - sd
println "Generated site into $outputDir in ${dur}ms"
}
private List<Section> renderDocumentation() {
siteMap.documentationSections.each { Section section ->
section.items.each { SectionItem item ->
if (item.generate) {
println "Generating documentation page [$item.name]"
render 'docpage', item.targetFilename, [
category: 'Learn',
title : item.name,
page : parsePage("${DocUtils.DOCS_BASEURL}/html/documentation/${item.sourceFilename}.html")]
}
}
}
}
private List<Page> renderPages(List<Changelog> changelogs) {
siteMap.pages.each { Page page ->
println "Rendering individual page [$page.source]"
if ('changelogs' == page.source) {
page.model.versions = changelogs.groovyVersion.sort(SEMANTIC_SORT)
}
render page.source, page.target, page.model
}
}
private List<Changelog> renderChangelogs(List<Changelog> changelogs) {
changelogs.each {
println "Rendering changelog for Groovy $it.groovyVersion"
render 'changelog', "changelog-$it.groovyVersion", [groovyVersion: it.groovyVersion, issues: it.issues], 'changelogs'
}
}
private void renderReleaseNotes() {
def releaseNotesVersions = new TreeSet<String>(new Comparator<String>() {
@Override
int compare(final String v1, final String v2) {
v2.toDouble() <=> v1.toDouble()
}
})
new File(sourcesDir, 'releasenotes').eachFile(FileType.FILES) { File file ->
def name = file.name.substring(0, file.name.lastIndexOf('.adoc'))
def version = name - 'groovy-'
releaseNotesVersions << version
println "Rendering release notes for Groovy $version"
render 'release-notes', name, [notes: file.getText('utf-8'), groovyVersion: version], 'releasenotes'
}
render 'releases', 'releases', [versions: releaseNotesVersions]
}
private void renderWiki() {
def asciidoctor = AsciidoctorFactory.instance
println "Rendering wiki"
def wikiDir = new File(sourcesDir, "wiki")
def gepList = [:]
wikiDir.eachFileRecurse { f->
if (f.name.endsWith('.adoc')) {
def header = asciidoctor.readDocumentHeader(f)
def bn = f.name.substring(0, f.name.lastIndexOf('.adoc'))
def author = header.author?.fullName
if (!author) {
author = header.authors*.fullName.join(', ')
}
println "Rendering $header.documentTitle.combined${author ? ' by ' + author : ''}"
def relativePath = []
def p = f.parentFile
while (p != wikiDir) {
relativePath << p.name
p = p.parentFile
}
String baseDir = relativePath ? "wiki${File.separator}${relativePath.join(File.separator)}" : 'wiki'
render 'wiki', bn, [notes:f.getText('utf-8'), header: header], baseDir
if (f.name.startsWith('GEP-')) {
gepList[bn] = header.documentTitle.subtitle
}
}
}
render 'geps', "geps", [list: gepList], 'wiki'
}
private void renderBlog() {
def asciidoctor = AsciidoctorFactory.instanceasciidoctor.requireLibrary('asciidoctor-diagram')
println "Rendering blogs"
def blogDir = new File(sourcesDir, "blog")
Map<String, Document> blogList = [:]
Map<String, String> contents = [:]
Map<String, String> baseDirs = [:]
blogDir.eachFileRecurse { f->
if (f.name.endsWith('.adoc')) {
def bn = f.name.substring(0, f.name.lastIndexOf('.adoc'))
def options = Options.builder().build()
def doc = asciidoctor.loadFile(f, options)
println "Rendering $bn"
def relativePath = []
def p = f.parentFile
while (p != blogDir) {
relativePath << p.name
p = p.parentFile
}
String baseDir = relativePath ? "blog${File.separator}${relativePath.join(File.separator)}" : 'blog'
blogList[bn] = doc
contents[bn] = f.getText('utf-8')
baseDirs[bn] = baseDir
}
}
Map<String, Set> keywords = [:]
blogList.each { k, v ->
String kw = v.attributes.keywords.toString()
keywords[k] = kw?.split(',')*.trim().toSet()
def groovyVersionInTitle = v.structuredDoctitle.combined.findAll(/(?i)(groovy \d[.]\d+[.]\d+[-\S]*)/)
groovyVersionInTitle?.each {keywords[k] << it }
def groovyMinorVersionInTitle = v.structuredDoctitle.combined.findAll(/(?i)(groovy \d[.]\d+)/)
groovyMinorVersionInTitle?.each {keywords[k] << it }
}
Map<String, Map<String, Integer>> related = [:].withDefault{ [:] }
[blogList.keySet(), blogList.keySet()].eachCombination { String one, String two ->
if (one != two) {
related[one][two] = keywords[one].intersect(keywords[two]).size()
}
}
blogList.keySet().each {bn ->
def sorted = related[bn].findAll { it.value as int > 1 }.sort { it.value }.keySet().toList().reverse()
render 'blog', bn, [notes:contents[bn], doc: blogList[bn], related: sorted.collectEntries{ [it, blogList[it].structuredDoctitle.combined]}], baseDirs[bn]
}
render 'blogs', "index", [list: blogList], 'blog'
renderBlogFeed blogList, 'blog'
}
@CompileDynamic
private void renderBlogFeed(Map<String, Document> blogList, String baseDir) {
def sorted = blogList.sort { e -> e.value.revisionInfo.date }
def base = "http://groovy.apache.org/$baseDir"
def feedDir = new File(outputDir, baseDir)
feedDir.mkdirs()
def feedFile = new File(feedDir, 'feed.atom')
def builder = new StreamingMarkupBuilder()
builder.encoding = 'UTF-8'
def blogs = builder.bind {
mkp.xmlDeclaration()
namespaces << ['':'http://www.w3.org/2005/Atom']
feed {
title('Groovy Blogs')
subtitle('News and stories from the Groovy Ecosystem')
link(href: base)
link(href: "$base/feed.atom", rel: 'self')
id(base)
sorted.each { k, v ->
def publishDate = v.revisionInfo.date
def updateDate = v.attributes.updated ?: v.revisionInfo.date
// Atom standard is a little vague on author tag.
// Multiple are allowed but many atom readers just display
// first or last, so we'll have one combined one.
def authorName = null
if (v.authors) {
authorName = v.authors*.fullName.join(', ')
}
entry {
if (authorName) {
author {
name(authorName)
}
}
title(v.structuredDoctitle.combined)
link(href: "$base/$k")
updated(updateDate)
published(publishDate)
summary(v.attributes.description ?: '')
}
}
}
}
feedFile.text = XmlUtil.serialize(blogs)
}
static void main(String... args) {
def sourcesDir = args[0] as File
def outputDir = args[1] as File
def sitemapFilename = args[2]
def generator = new SiteGenerator(sourcesDir: sourcesDir, outputDir: outputDir, sitemapFilename: sitemapFilename)
boolean watchMode = args.length > 3 ? Boolean.valueOf(args[3]) : false
generator.generateSite()
if (watchMode) {
println "Started watch mode"
def watcher = FileSystems.default.newWatchService()
sourcesDir.toPath().register(watcher,
ENTRY_CREATE,
ENTRY_DELETE,
ENTRY_MODIFY)
sourcesDir.eachDirRecurse { File f ->
f.toPath().register(watcher,
ENTRY_CREATE,
ENTRY_DELETE,
ENTRY_MODIFY)
}
def existingDirectories = ['pages', 'layouts', 'includes', 'html', 'assets', 'css', 'fonts', 'img', 'js', 'vendor']
while (true) {
def key = watcher.take()
def pollEvents = (List<WatchEvent<Path>>) key.pollEvents()
def changed = pollEvents.collect { "${it.context()}".toString() }.join(', ')
// only generate when the event refers to the actual file modified / created / added
// as otherwise the watcher service generates two events:
// 1) one for directory containing the modified file, and
// 2) one for the actual file being modified
// this checks avoid getting two events for one change
if (existingDirectories.every { !changed.contains(it) }) {
try {
println "Regenerating site due to changes in: ${changed}"
// todo: selective regeneration
generator.generateSite()
} finally {
key.reset()
}
}
}
}
}
static List<String> decomposeVersion(String version) {
String qualifier = ''
if (version.indexOf('-')>0) {
qualifier = version.substring(version.indexOf('-'))
version = version - qualifier
}
List<String> parts = version.split(/\./).toList()
if (qualifier) {
parts << qualifier
}
parts
}
static boolean exists(String u) {
def url = new URL(u)
HttpURLConnection.setFollowRedirects(false)
HttpURLConnection connection = (HttpURLConnection) url.openConnection()
connection.setRequestMethod("HEAD")
// pretend to be a browser to keep fussy websites a little happier
connection.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.1.2) Gecko/20090729 Firefox/3.5.2 (.NET CLR 3.5.30729)")
return connection.responseCode == HttpURLConnection.HTTP_OK
}
}