Add single file audio player, introduce blocks

CHDataManagement/Generator/Blocks/AudioBlockProcessor.swift

@@ -0,0 +1,62 @@
+
+struct AudioBlockProcessor: KeyedBlockProcessor {
+
+    enum Key: String {
+        case name
+        case artist
+        case album
+        case file
+        case cover
+    }
+
+    static let blockId: ContentBlock = .audio
+
+    let content: Content
+    
+    let results: PageGenerationResults
+    
+    let language: ContentLanguage
+    
+    init(content: Content, results: PageGenerationResults, language: ContentLanguage) {
+        self.content = content
+        self.results = results
+        self.language = language
+    }
+
+    func process(_ arguments: [Key : String], markdown: Substring) -> String {
+        guard let name = arguments[.name],
+              let artist = arguments[.artist],
+              let album = arguments[.album],
+              let fileId = arguments[.file],
+              let cover = arguments[.cover] else {
+            invalid(markdown)
+            return ""
+        }
+
+        guard let image = content.image(cover) else {
+            results.missing(file: cover, source: "Audio Block")
+            return ""
+        }
+
+        guard let file = content.file(fileId) else {
+            results.missing(file: fileId, source: "Audio Block")
+            return ""
+        }
+
+        let coverSize = 2 * content.settings.audioPlayer.smallCoverImageSize
+        let coverImage = image.imageVersion(width: coverSize, height: coverSize, type: image.type)
+        let footer = SingleFilePlayer.footer(
+            name: name,
+            artist: artist,
+            album: album,
+            url: file.absoluteUrl,
+            cover: coverImage.outputPath)
+
+        results.require(image: coverImage)
+        results.require(footer: footer)
+        results.require(headers: .audioPlayerJs, .audioPlayerCss)
+        results.require(icons: .audioPlayerPlay, .audioPlayerPause)
+
+        return SingleFilePlayer().content
+    }
+}

CHDataManagement/Generator/Blocks/BlockProcessor.swift

@@ -0,0 +1,86 @@
+
+enum ContentBlock: String, CaseIterable {
+
+    case audio
+
+    case swift
+
+    var processor: BlockProcessor.Type {
+        switch self {
+        case .audio: return AudioBlockProcessor.self
+        case .swift: return SwiftBlockProcessor.self
+        }
+    }
+}
+
+protocol BlockProcessor {
+
+    static var blockId: ContentBlock { get }
+
+    var results: PageGenerationResults { get }
+
+    init(content: Content, results: PageGenerationResults, language: ContentLanguage)
+
+    func process(_ markdown: Substring) -> String
+}
+
+extension BlockProcessor {
+
+    func invalid(_ markdown: Substring) {
+        results.invalid(block: Self.blockId, markdown)
+    }
+}
+
+protocol BlockLineProcessor: BlockProcessor {
+
+    func process(_ lines: [String], markdown: Substring) -> String
+}
+
+extension BlockLineProcessor {
+
+    func process(_ markdown: Substring) -> String {
+        let lines = markdown
+            .between("```\(Self.blockId.self)", and: "```")
+            .components(separatedBy: "\n")
+        return process(lines, markdown: markdown)
+    }
+}
+
+protocol OrderedKeyBlockProcessor: BlockLineProcessor {
+
+    associatedtype Key: Hashable, RawRepresentable where Key.RawValue == String
+
+    func process(_ arguments: [(key: Key, value: String)], markdown: Substring) -> String
+}
+
+extension OrderedKeyBlockProcessor {
+
+    func process(_ lines: [String], markdown: Substring) -> String {
+        let result: [(key: Key, value: String)] = lines.compactMap { line in
+            guard line.trimmed != "" else {
+                return nil
+            }
+            let (rawKey, rawValue) = line.splitAtFirst(":")
+            guard let key = Key(rawValue: rawKey.trimmed) else {
+                print("Invalid key \(rawKey)")
+                invalid(markdown)
+                return nil
+            }
+            return (key, rawValue.trimmed)
+        }
+        return process(result, markdown: markdown)
+    }
+}
+
+protocol KeyedBlockProcessor: OrderedKeyBlockProcessor {
+
+    func process(_ arguments: [Key : String], markdown: Substring) -> String
+}
+
+extension KeyedBlockProcessor {
+
+    func process(_ arguments: [(key: Key, value: String)], markdown: Substring) -> String {
+        let result = arguments.reduce(into: [:]) { $0[$1.key] = $1.value }
+        return process(result, markdown: markdown)
+    }
+}

CHDataManagement/Generator/Blocks/CodeBlockProcessor.swift

@@ -0,0 +1,33 @@
+
+struct CodeBlockProcessor {
+
+    private let codeHighlightFooter = "<script>hljs.highlightAll();</script>"
+
+    let results: PageGenerationResults
+
+    private let blocks: [ContentBlock : BlockProcessor]
+
+    private let other: OtherCodeProcessor
+
+    init(content: Content, results: PageGenerationResults, language: ContentLanguage) {
+        self.results = results
+        self.other = .init(results: results)
+
+        self.blocks = ContentBlock.allCases.reduce(into: [:]) { blocks, block in
+            blocks[block] = block.processor.init(content: content, results: results, language: language)
+        }
+    }
+
+    func process(_ html: String, markdown: Substring) -> String {
+        let input = String(markdown)
+        let rawBlockId = input.dropAfterFirst("\n").dropBeforeFirst("```").trimmed
+        guard let blockId = ContentBlock(rawValue: rawBlockId) else {
+            return other.process(html: html)
+        }
+        guard let processor = self.blocks[blockId] else {
+            results.invalid(block: blockId, markdown)
+            return ""
+        }
+        return processor.process(markdown)
+    }
+}

CHDataManagement/Generator/Blocks/OtherCodeProcessor.swift

@@ -0,0 +1,17 @@
+
+struct OtherCodeProcessor {
+
+    private let codeHighlightFooter = "<script>hljs.highlightAll();</script>"
+
+    let results: PageGenerationResults
+
+    init(results: PageGenerationResults) {
+        self.results = results
+    }
+
+    func process(html: String) -> String {
+        results.require(header: .codeHightlighting)
+        results.require(footer: codeHighlightFooter)
+        return html // Just use normal code highlighting
+    }
+}

CHDataManagement/Generator/Blocks/SwiftProcessor.swift

@@ -0,0 +1,26 @@
+import Splash
+
+struct SwiftBlockProcessor: BlockProcessor {
+
+    static let blockId: ContentBlock = .swift
+
+    let content: Content
+
+    let results: PageGenerationResults
+
+    let language: ContentLanguage
+
+    private let swift = SyntaxHighlighter(format: HTMLOutputFormat())
+
+    init(content: Content, results: PageGenerationResults, language: ContentLanguage) {
+        self.content = content
+        self.results = results
+        self.language = language
+    }
+
+    func process(_ markdown: Substring) -> String {
+        // Highlight swift code using Splash
+        let code = markdown.between("```swift", and: "```").trimmed
+        return "<pre><code>" + swift.highlight(code) + "</pre></code>"
+    }
+}