344 lines
15 KiB
Swift
344 lines
15 KiB
Swift
import Foundation
|
|
import Ink
|
|
import Splash
|
|
|
|
struct PageContentGenerator {
|
|
|
|
private let largeImageIndicator = "*large*"
|
|
|
|
private let factory: TemplateFactory
|
|
|
|
private let swift = SyntaxHighlighter(format: HTMLOutputFormat())
|
|
|
|
private let siteRoot: Element
|
|
|
|
private let results: GenerationResultsHandler
|
|
|
|
init(factory: TemplateFactory, siteRoot: Element, results: GenerationResultsHandler) {
|
|
self.factory = factory
|
|
self.siteRoot = siteRoot
|
|
self.results = results
|
|
}
|
|
|
|
func generate(page: Element, language: String, content: String) -> (content: String, includesCode: Bool) {
|
|
var hasCodeContent = false
|
|
var largeImageCount = 0
|
|
|
|
let imageModifier = Modifier(target: .images) { html, markdown in
|
|
processMarkdownImage(markdown: markdown, html: html, page: page, language: language, largeImageCount: &largeImageCount)
|
|
}
|
|
let codeModifier = Modifier(target: .codeBlocks) { html, markdown in
|
|
if markdown.starts(with: "```swift") {
|
|
let code = markdown.between("```swift", and: "```").trimmed
|
|
return "<pre><code>" + swift.highlight(code) + "</pre></code>"
|
|
}
|
|
hasCodeContent = true
|
|
return html
|
|
}
|
|
let linkModifier = Modifier(target: .links) { html, markdown in
|
|
handleLink(page: page, language: language, html: html, markdown: markdown)
|
|
}
|
|
let htmlModifier = Modifier(target: .html) { html, markdown in
|
|
handleHTML(page: page, language: language, html: html, markdown: markdown)
|
|
}
|
|
|
|
let parser = MarkdownParser(modifiers: [imageModifier, codeModifier, linkModifier, htmlModifier])
|
|
return (parser.html(from: content), hasCodeContent)
|
|
}
|
|
|
|
private func handleLink(page: Element, language: String, html: String, markdown: Substring) -> String {
|
|
let file = markdown.between("(", and: ")")
|
|
if file.hasPrefix("page:") {
|
|
let pageId = file.replacingOccurrences(of: "page:", with: "")
|
|
guard let pagePath = results.getPagePath(for: pageId, source: page.path, language: language) else {
|
|
// Remove link since the page can't be found
|
|
return markdown.between("[", and: "]")
|
|
}
|
|
// Adjust file path to get the page url
|
|
let url = page.relativePathToOtherSiteElement(file: pagePath)
|
|
return html.replacingOccurrences(of: file, with: url)
|
|
}
|
|
|
|
if let filePath = page.nonAbsolutePathRelativeToRootForContainedInputFile(file) {
|
|
// The target of the page link must be present after generation is complete
|
|
results.expect(file: filePath, source: page.path)
|
|
}
|
|
return html
|
|
}
|
|
|
|
private func handleHTML(page: Element, language: String, html: String, markdown: Substring) -> String {
|
|
// TODO: Check HTML code in markdown for required resources
|
|
//print("[HTML] Found in page \(page.path):")
|
|
//print(markdown)
|
|
// Things to check:
|
|
// <img src=
|
|
// <a href=
|
|
//
|
|
return html
|
|
}
|
|
|
|
private func processMarkdownImage(markdown: Substring, html: String, page: Element, language: String, largeImageCount: inout Int) -> String {
|
|
// Split the markdown 
|
|
// There are several known shorthand commands
|
|
// For images: 
|
|
// For videos: 
|
|
// For svg with custom area: 
|
|
// For downloads: 
|
|
// For a simple boxes: 
|
|
// A fancy page link: 
|
|
// External pages: 
|
|
let fileAndTitle = markdown.between("(", and: ")")
|
|
let alt = markdown.between("[", and: "]").nonEmpty
|
|
if let alt = alt, let command = ShorthandMarkdownKey(rawValue: alt) {
|
|
return handleShortHandCommand(command, page: page, language: language, content: fileAndTitle)
|
|
}
|
|
|
|
let file = fileAndTitle.dropAfterFirst(" ")
|
|
let title = fileAndTitle.contains(" ") ? fileAndTitle.dropBeforeFirst(" ").nonEmpty : nil
|
|
|
|
let fileExtension = file.lastComponentAfter(".").lowercased()
|
|
if let _ = ImageType(fileExtension: fileExtension) {
|
|
return handleImage(page: page, file: file, rightTitle: title, leftTitle: alt, largeImageCount: &largeImageCount)
|
|
}
|
|
if let _ = VideoType(rawValue: fileExtension) {
|
|
return handleVideo(page: page, file: file, optionString: alt)
|
|
}
|
|
switch fileExtension {
|
|
case "svg":
|
|
return handleSvg(page: page, file: file, area: alt)
|
|
case "gif":
|
|
return handleGif(page: page, file: file, altText: alt ?? "gif image")
|
|
default:
|
|
return handleFile(page: page, file: file, fileExtension: fileExtension)
|
|
}
|
|
}
|
|
|
|
private func handleShortHandCommand(_ command: ShorthandMarkdownKey, page: Element, language: String, content: String) -> String {
|
|
switch command {
|
|
case .downloadButtons:
|
|
return handleDownloadButtons(page: page, content: content)
|
|
case .externalLink:
|
|
return handleExternalButtons(page: page, content: content)
|
|
case .includedHtml:
|
|
return handleExternalHTML(page: page, file: content)
|
|
case .box:
|
|
return handleSimpleBox(page: page, content: content)
|
|
case .pageLink:
|
|
return handlePageLink(page: page, language: language, pageId: content)
|
|
}
|
|
}
|
|
|
|
private func handleImage(page: Element, file: String, rightTitle: String?, leftTitle: String?, largeImageCount: inout Int) -> String {
|
|
let imagePath = page.pathRelativeToRootForContainedInputFile(file)
|
|
let left: String
|
|
let createFullScreenVersion: Bool
|
|
if let leftTitle {
|
|
createFullScreenVersion = leftTitle.hasPrefix(largeImageIndicator)
|
|
left = leftTitle.dropBeforeFirst(largeImageIndicator).trimmed
|
|
} else {
|
|
left = ""
|
|
createFullScreenVersion = false
|
|
}
|
|
let size = results.requireFullSizeMultiVersionImage(
|
|
source: imagePath,
|
|
destination: imagePath,
|
|
requiredBy: page.path)
|
|
|
|
let altText = left.nonEmpty ?? rightTitle ?? "image"
|
|
|
|
var content = [PageImageTemplateKey : String]()
|
|
content[.altText] = altText
|
|
content[.image] = file.dropAfterLast(".")
|
|
content[.imageExtension] = file.lastComponentAfter(".")
|
|
content[.width] = "\(Int(size.width))"
|
|
content[.height] = "\(Int(size.height))"
|
|
content[.leftText] = left
|
|
content[.rightText] = rightTitle ?? ""
|
|
|
|
guard createFullScreenVersion else {
|
|
return factory.image.generate(content)
|
|
}
|
|
|
|
results.requireOriginalSizeImages(
|
|
source: imagePath,
|
|
destination: imagePath,
|
|
requiredBy: page.path)
|
|
|
|
largeImageCount += 1
|
|
content[.number] = "\(largeImageCount)"
|
|
return factory.largeImage.generate(content)
|
|
}
|
|
|
|
private func handleVideo(page: Element, file: String, optionString: String?) -> String {
|
|
let options: [PageVideoTemplate.VideoOption] = optionString.unwrapped { string in
|
|
string.components(separatedBy: " ").compactMap { optionText -> PageVideoTemplate.VideoOption? in
|
|
guard let optionText = optionText.trimmed.nonEmpty else {
|
|
return nil
|
|
}
|
|
guard let option = PageVideoTemplate.VideoOption(rawValue: optionText) else {
|
|
results.warning("Unknown video option \(optionText)", source: page.path)
|
|
return nil
|
|
}
|
|
return option
|
|
}
|
|
} ?? []
|
|
// TODO: Check page folder for alternative video versions
|
|
let sources: [PageVideoTemplate.VideoSource] = [(url: file, type: .mp4)]
|
|
|
|
let filePath = page.pathRelativeToRootForContainedInputFile(file)
|
|
results.require(file: filePath, source: page.path)
|
|
return factory.video.generate(sources: sources, options: options)
|
|
}
|
|
|
|
private func handleGif(page: Element, file: String, altText: String) -> String {
|
|
let imagePath = page.pathRelativeToRootForContainedInputFile(file)
|
|
results.require(file: imagePath, source: page.path)
|
|
|
|
guard let size = results.getImageSize(atPath: imagePath, source: page.path) else {
|
|
return ""
|
|
}
|
|
let width = Int(size.width)
|
|
let height = Int(size.height)
|
|
return factory.html.image(file: file, width: width, height: height, altText: altText)
|
|
}
|
|
|
|
private func handleSvg(page: Element, file: String, area: String?) -> String {
|
|
let imagePath = page.pathRelativeToRootForContainedInputFile(file)
|
|
results.require(file: imagePath, source: page.path)
|
|
|
|
guard let size = results.getImageSize(atPath: imagePath, source: page.path) else {
|
|
return "" // Missing image warning already produced
|
|
}
|
|
let width = Int(size.width)
|
|
let height = Int(size.height)
|
|
|
|
var altText = "image " + file.lastComponentAfter("/")
|
|
guard let area = area else {
|
|
return factory.html.image(file: file, width: width, height: height, altText: altText)
|
|
}
|
|
let parts = area.components(separatedBy: ",").map { $0.trimmed }
|
|
switch parts.count {
|
|
case 1:
|
|
return factory.html.image(file: file, width: width, height: height, altText: parts[0])
|
|
case 4:
|
|
break
|
|
case 5:
|
|
altText = parts[4]
|
|
default:
|
|
results.warning("Invalid area string for svg image", source: page.path)
|
|
return factory.html.image(file: file, width: width, height: height, altText: altText)
|
|
}
|
|
guard let x = Int(parts[0]),
|
|
let y = Int(parts[1]),
|
|
let partWidth = Int(parts[2]),
|
|
let partHeight = Int(parts[3]) else {
|
|
results.warning("Invalid area string for svg image", source: page.path)
|
|
return factory.html.image(file: file, width: width, height: height, altText: altText)
|
|
}
|
|
let part = SVGSelection(x, y, partWidth, partHeight)
|
|
return factory.html.svgImage(file: file, part: part, altText: altText)
|
|
}
|
|
|
|
private func handleFile(page: Element, file: String, fileExtension: String) -> String {
|
|
results.warning("Unhandled file \(file) with extension \(fileExtension)", source: page.path)
|
|
return ""
|
|
}
|
|
|
|
private func handleDownloadButtons(page: Element, content: String) -> String {
|
|
let buttons = content
|
|
.components(separatedBy: ";")
|
|
.compactMap { button -> (file: String, text: String, downloadName: String?)? in
|
|
let parts = button.components(separatedBy: ",")
|
|
guard parts.count == 2 || parts.count == 3 else {
|
|
results.warning("Invalid button definition", source: page.path)
|
|
return nil
|
|
}
|
|
let file = parts[0].trimmed
|
|
let title = parts[1].trimmed
|
|
let downloadName = parts.count == 3 ? parts[2].trimmed : nil
|
|
|
|
// Ensure that file is available
|
|
let filePath = page.pathRelativeToRootForContainedInputFile(file)
|
|
results.require(file: filePath, source: page.path)
|
|
|
|
return (file, title, downloadName)
|
|
}
|
|
return factory.html.downloadButtons(buttons)
|
|
}
|
|
|
|
private func handleExternalButtons(page: Element, content: String) -> String {
|
|
let buttons = content
|
|
.components(separatedBy: ";")
|
|
.compactMap { button -> (url: String, text: String)? in
|
|
let parts = button.components(separatedBy: ",")
|
|
guard parts.count == 2 else {
|
|
results.warning("Invalid external link definition", source: page.path)
|
|
return nil
|
|
}
|
|
let url = parts[0].trimmed
|
|
let title = parts[1].trimmed
|
|
|
|
return (url, title)
|
|
}
|
|
return factory.html.externalButtons(buttons)
|
|
}
|
|
|
|
private func handleExternalHTML(page: Element, file: String) -> String {
|
|
let path = page.pathRelativeToRootForContainedInputFile(file)
|
|
return results.getContentOfRequiredFile(at: path, source: page.path) ?? ""
|
|
}
|
|
|
|
private func handleSimpleBox(page: Element, content: String) -> String {
|
|
let parts = content.components(separatedBy: ";")
|
|
guard parts.count > 1 else {
|
|
results.warning("Invalid box specification", source: page.path)
|
|
return ""
|
|
}
|
|
let title = parts[0]
|
|
let text = parts.dropFirst().joined(separator: ";")
|
|
return factory.makePlaceholder(title: title, text: text)
|
|
}
|
|
|
|
private func handlePageLink(page: Element, language: String, pageId: String) -> String {
|
|
guard let linkedPage = siteRoot.find(pageId) else {
|
|
// Checking the page path will add it to the missing pages
|
|
_ = results.getPagePath(for: pageId, source: page.path, language: language)
|
|
// Remove link since the page can't be found
|
|
return ""
|
|
}
|
|
var content = [PageLinkTemplate.Key: String]()
|
|
|
|
content[.title] = linkedPage.title(for: language)
|
|
content[.altText] = ""
|
|
|
|
let fullThumbnailPath = linkedPage.thumbnailFilePath(for: language).destination
|
|
// Note: Here we assume that the thumbnail was already used elsewhere, so already generated
|
|
let relativeImageUrl = page.relativePathToOtherSiteElement(file: fullThumbnailPath)
|
|
let metadata = linkedPage.localized(for: language)
|
|
|
|
if linkedPage.state.hasThumbnailLink {
|
|
let fullPageUrl = linkedPage.fullPageUrl(for: language)
|
|
let relativePageUrl = page.relativePathToOtherSiteElement(file: fullPageUrl)
|
|
content[.url] = "href=\"\(relativePageUrl)\""
|
|
}
|
|
|
|
content[.image] = relativeImageUrl.dropAfterLast(".")
|
|
if let suffix = metadata.thumbnailSuffix {
|
|
content[.title] = factory.html.make(title: metadata.title, suffix: suffix)
|
|
} else {
|
|
content[.title] = metadata.title
|
|
}
|
|
|
|
let path = linkedPage.makePath(language: language, from: siteRoot)
|
|
content[.path] = factory.pageLink.makePath(components: path)
|
|
|
|
content[.description] = metadata.relatedContentText
|
|
if let parent = linkedPage.findParent(from: siteRoot), parent.thumbnailStyle == .large {
|
|
content[.className] = " related-page-link-large"
|
|
}
|
|
|
|
// We assume that the thumbnail images are already required by overview pages.
|
|
return factory.pageLink.generate(content)
|
|
}
|
|
}
|