Process post content as markdown

CHDataManagement/Generator/Markdown/ItemLinkResults.swift

@@ -0,0 +1,18 @@
+
+protocol ItemLinkResults {
+
+    func externalLink(to url: String)
+
+    func missing(page: String, source: String)
+
+    func linked(to page: Page)
+
+    func missing(tag: String, source: String)
+
+    func linked(to tag: Tag)
+
+    func missing(file: String, source: String)
+
+    func require(file: FileResource)
+}
+

CHDataManagement/Generator/Markdown/MarkdownLinkProcessor.swift

@@ -1,84 +1,110 @@
 import Ink
 
+extension PageGenerationResults: ItemLinkResults {
+
+}
+
 struct MarkdownLinkProcessor: MarkdownProcessor {
 
     static let modifier: Modifier.Target = .links
 
     private let content: Content
 
-    private let results: PageGenerationResults
+    private let results: ItemLinkResults
 
     private let language: ContentLanguage
 
+    init(content: Content, results: ItemLinkResults, language: ContentLanguage) {
+        self.content = content
+        self.results = results
+        self.language = language
+    }
+
     init(content: Content, results: PageGenerationResults, language: ContentLanguage) {
         self.content = content
         self.results = results
         self.language = language
     }
 
+    func process(html: String, markdown: Substring) -> String {
+        let markdownUrl = markdown.between("(", and: ")")
+        guard let (textToReplace, url) = convert(markdownUrl: markdownUrl) else {
+            // Keep original code, no changes needed
+            return html
+        }
+        guard let convertedUrl = url else {
+            // Remove link since the target can't be found
+            return markdown.between("[", and: "]")
+        }
+        return html.replacingOccurrences(of: textToReplace, with: convertedUrl)
+    }
+
     private let pageLinkMarker = "page:"
 
     private let tagLinkMarker = "tag:"
 
     private let fileLinkMarker = "file:"
 
-    func process(html: String, markdown: Substring) -> String {
-        let url = markdown.between("(", and: ")")
-        if url.hasPrefix(pageLinkMarker) {
-            return handleInlinePageLink(url: url, html: html, markdown: markdown)
+    func convert(markdownUrl: String) -> (textToChange: String, url: String?)? {
+        if let result = handle(prefix: pageLinkMarker, in: markdownUrl, handler: convert(inlinePageLink:)) {
+            return result
         }
-        if url.hasPrefix(tagLinkMarker) {
-            return handleInlineTagLink(url: url, html: html, markdown: markdown)
+        if let result = handle(prefix: tagLinkMarker, in: markdownUrl, handler: convert(inlineTagLink:)) {
+            return result
         }
-        if url.hasPrefix(fileLinkMarker) {
-            return handleInlineFileLink(url: url, html: html, markdown: markdown)
+        if let result = handle(prefix: fileLinkMarker, in: markdownUrl, handler: convert(inlineFileLink:)) {
+            return result
         }
-        results.externalLink(to: url)
-        return html
+        results.externalLink(to: markdownUrl)
+        // No need to change anything
+        return nil
     }
 
-    private func handleInlinePageLink(url: String, html: String, markdown: Substring) -> String {
-        // Retain links pointing to elements within a page
-        let textToChange = url.dropAfterFirst("#")
-        let pageId = textToChange.replacingOccurrences(of: pageLinkMarker, with: "")
+    private func handle(prefix: String, in markdownUrl: String, handler: (String) -> String?)  -> (textToChange: String, url: String?)? {
+        guard markdownUrl.hasPrefix(prefix) else {
+            // Continue search
+            return nil
+        }
+        let inlineLink = markdownUrl.replacingOccurrences(of: prefix, with: "")
+        let itemId = inlineLink.dropAfterFirst("#")
+        let url = handler(itemId)
+        return (textToChange: prefix + itemId, url: url)
+    }
+
+    private func convert(inlinePageLink pageId: String) -> String? {
         guard let page = content.page(pageId) else {
             results.missing(page: pageId, source: "Inline page link")
             // Remove link since the page can't be found
-            return markdown.between("[", and: "]")
+            return nil
         }
-        guard !page.isDraft else {
-            return markdown.between("[", and: "]")
-        }
-
+        // Note link even for draft pages
         results.linked(to: page)
-        let pagePath = page.absoluteUrl(in: language)
-        return html.replacingOccurrences(of: textToChange, with: pagePath)
+
+        guard !page.isDraft else {
+            // TODO: Report links to draft pages
+            return nil
+        }
+        return page.absoluteUrl(in: language)
     }
 
-    private func handleInlineTagLink(url: String, html: String, markdown: Substring) -> String {
-        // Retain links pointing to elements within a page
-        let textToChange = url.dropAfterFirst("#")
-        let tagId = textToChange.replacingOccurrences(of: tagLinkMarker, with: "")
+    private func convert(inlineTagLink: String) -> String? {
+        let tagId = inlineTagLink.dropAfterFirst("#")
         guard let tag = content.tag(tagId) else {
             results.missing(tag: tagId, source: "Inline tag link")
             // Remove link since the tag can't be found
-            return markdown.between("[", and: "]")
+            return nil
         }
         results.linked(to: tag)
-        let tagPath = tag.absoluteUrl(in: language)
-        return html.replacingOccurrences(of: textToChange, with: tagPath)
+        return tag.absoluteUrl(in: language)
     }
 
-    private func handleInlineFileLink(url: String, html: String, markdown: Substring) -> String {
-        // Retain links pointing to elements within a page
-        let fileId = url.replacingOccurrences(of: fileLinkMarker, with: "")
+    private func convert(inlineFileLink fileId: String) -> String? {
         guard let file = content.file(fileId) else {
             results.missing(file: fileId, source: "Inline file link")
             // Remove link since the file can't be found
-            return markdown.between("[", and: "]")
+            return nil
         }
         results.require(file: file)
-        let filePath = file.absoluteUrl
-        return html.replacingOccurrences(of: url, with: filePath)
+        return file.absoluteUrl
     }
 }

CHDataManagement/Generator/Post Lists/PostContentGenerator.swift

@@ -0,0 +1,93 @@
+import Foundation
+import Ink
+
+struct PostContentGenerator {
+
+    private let content: Content
+
+    private let results: PageGenerationResults
+
+    private let language: ContentLanguage
+
+    private let post: Post
+
+    init(content: Content, results: PageGenerationResults, language: ContentLanguage, post: Post) {
+        self.content = content
+        self.results = results
+        self.language = language
+        self.post = post
+    }
+
+    func generate() -> String {
+        let parser = MarkdownParser(modifiers: [
+            Modifier(target: .images, closure: handleImage),
+            Modifier(target: .codeBlocks, closure: handleCode),
+            Modifier(target: .links, closure: handleLink)
+        ])
+        return parser.html(from: post.localized(in: language).text)
+    }
+
+    private func handleImage(
+        html: String,
+        markdown: Substring
+    ) -> String {
+        results.warning("Image in \(postDescription)")
+        return ""
+    }
+
+    private func handleCode(
+        html: String,
+        markdown: Substring
+    ) -> String {
+        results.warning("Code in \(postDescription)")
+        return ""
+    }
+
+    private var postDescription: String {
+        "content of post \(post.id) (\(language.shortText))"
+    }
+
+    private func handleLink(
+        html: String,
+        markdown: Substring
+    ) -> String {
+        let converter = MarkdownLinkProcessor(content: content, results: self, language: language)
+        let markdownUrl = markdown.between("(", and: ")")
+        let text = markdown.between("[", and: "]")
+        guard let url = converter.convert(markdownUrl: markdownUrl)?.url else {
+            return text
+        }
+        return "<span class='link' onclick=\"location.href='\(url)'; event.stopPropagation();\">\(text)</span>"
+    }
+}
+
+extension PostContentGenerator: ItemLinkResults {
+
+    func externalLink(to url: String) {
+        results.externalLink(to: url)
+    }
+    
+    func missing(page: String, source: String) {
+        results.missing(page: page, source: postDescription)
+    }
+    
+    func linked(to page: Page) {
+        results.linked(to: page)
+    }
+    
+    func missing(tag: String, source: String) {
+        results.missing(tag: tag, source: postDescription)
+    }
+    
+    func linked(to tag: Tag) {
+        results.linked(to: tag)
+    }
+    
+    func missing(file: String, source: String) {
+        results.missing(file: file, source: postDescription)
+    }
+    
+    func require(file: FileResource) {
+        results.require(file: file)
+    }
+}

CHDataManagement/Generator/Post Lists/PostListPageGenerator.swift

@@ -58,7 +58,7 @@ final class PostListPageGenerator {
         }
     }
 
-    private func makePostData(post: Post) -> FeedEntryData {
+    private func makePostData(post: Post, results: PageGenerationResults) -> FeedEntryData {
         let localized: LocalizedPost = post.localized(in: language)
 
         let linkUrl: FeedEntryData.Link? = post.linkedPage.map {
@@ -88,6 +88,12 @@ final class PostListPageGenerator {
             media = nil
         }
 
+        let text = PostContentGenerator(
+            content: source.content,
+            results: source.results,
+            language: language,
+            post: post).generate()
+        
         return FeedEntryData(
             entryId: post.id,
             title: localized.title,
@@ -95,13 +101,12 @@ final class PostListPageGenerator {
             link: linkUrl,
             tags: tags,
             labels: localized.labels,
-            text: localized.text.components(separatedBy: "\n\n"),
+            text: text,
             media: media)
-        #warning("Treat post text as markdown")
     }
 
     private func createPostFeedPage(_ pageIndex: Int, pageCount: Int, posts: ArraySlice<Post>) {
-        let posts: [FeedEntryData] = posts.map(makePostData)
+        let posts: [FeedEntryData] = posts.map { makePostData(post: $0, results: source.results) }
 
         let feedPageGenerator = FeedPageGenerator(content: source.content, results: source.results)
 

CHDataManagement/Page Elements/FeedEntry.swift

@@ -35,9 +35,7 @@ struct FeedEntry: HtmlProducer {
         TagList(tags: data.tags).populate(&result)
         ContentLabels(labels: data.labels).populate(&result)
 
-        for paragraph in data.text {
-            result += "<p>\(paragraph)</p>"
-        }
+        result += data.text
         if let url = data.link {
             result += "<div class='link-center'><div class='link'>\(url.text)</div></div>"
         }

CHDataManagement/Page Elements/FeedEntryData.swift

@@ -13,11 +13,11 @@ struct FeedEntryData {
 
     let labels: [ContentLabel]
 
-    let text: [String]
+    let text: String
 
     let media: Media?
 
-    init(entryId: String, title: String?, textAboveTitle: String, link: Link?, tags: [Tag], labels: [ContentLabel], text: [String], media: Media?) {
+    init(entryId: String, title: String?, textAboveTitle: String, link: Link?, tags: [Tag], labels: [ContentLabel], text: String, media: Media?) {
         self.entryId = entryId
         self.title = title
         self.textAboveTitle = textAboveTitle