Rework content commands, add audio player

CHDataManagement/Generator/GenerationResultsHandler.swift

@@ -1,24 +0,0 @@
-import Foundation
-
-final class GenerationResultsHandler {
-
-    var requiredVideoFiles: Set<String> = []
-
-    /// Generic warnings for pages
-    private var pageWarnings: [(message: String, source: String)] = []
-
-    private var missingPages: [String : [String]] = [:]
-
-    func warning(_ message: String, page: Page) {
-        pageWarnings.append((message, page.id))
-        print("Page: \(page.id): \(message)")
-    }
-
-    func addRequiredVideoFile(fileId: String) {
-        requiredVideoFiles.insert(fileId)
-    }
-
-    func missing(page: String, linkedBy source: String) {
-        missingPages[page, default: []].append(source)
-    }
-}

CHDataManagement/Generator/LocalizedWebsiteGenerator.swift

@@ -130,7 +130,7 @@ final class LocalizedWebsiteGenerator {
             return true
         }
 
-        let path = self.content.absoluteUrlToPage(page, language: language) + ".html"
+        let path = page.absoluteUrl(for: language) + ".html"
         guard save(content, to: path) else {
             print("Failed to save page")
             return false
@@ -151,9 +151,8 @@ final class LocalizedWebsiteGenerator {
                 continue
             }
 
-            let outputPath = content.absoluteUrlToFile(file)
             do {
-                try content.storage.copy(file: file.id, to: outputPath)
+                try content.storage.copy(file: file.id, to: file.absoluteUrl)
             } catch {
                 print("Failed to copy file \(file.id): \(error)")
                 return false

CHDataManagement/Generator/Page Content/AudioPlayerCommand.swift

@@ -0,0 +1,94 @@
+import Foundation
+
+struct AudioPlayerCommandProcessor: CommandProcessor {
+
+    let commandType: ShorthandMarkdownKey = .audioPlayer
+
+    let content: Content
+
+    let results: PageGenerationResults
+
+    init(content: Content, results: PageGenerationResults) {
+        self.content = content
+        self.results = results
+    }
+
+    func process(_ arguments: [String], markdown: Substring) -> String {
+        guard arguments.count == 2 else {
+            results.invalid(command: .audioPlayer, "Invalid audio player arguments")
+            return ""
+        }
+        let fileId = arguments[0]
+        let titleText = arguments[1]
+
+        guard content.isValidIdForFile(fileId) else {
+            results.invalid(command: .audioPlayer, "Invalid file id \(fileId) for audio player")
+            return ""
+        }
+
+        guard let file = content.file(fileId) else {
+            results.missingFiles.insert(fileId)
+            return ""
+        }
+        let songs: [Song]
+        do {
+            let data = try file.dataContent()
+            songs = try JSONDecoder().decode([Song].self, from: data)
+        } catch {
+            results.issues.insert(.failedToLoadContent(error))
+            return ""
+        }
+
+        var playlist: [AudioPlayer.PlaylistItem] = []
+        var amplitude: [AmplitudeSong] = []
+
+        for song in songs {
+            guard let image = content.image(song.cover) else {
+                results.missing(file: song.cover, markdown: "Missing cover image \(song.cover) in \(file.id)")
+                continue
+            }
+
+            guard let audioFile = content.file(song.file) else {
+                results.missing(file: song.file, markdown: "Missing audio file \(song.file) in \(file.id)")
+                continue
+            }
+            #warning("Check if file is audio")
+            let coverUrl = image.absoluteUrl
+
+            let playlistItem = AudioPlayer.PlaylistItem(
+                index: playlist.count,
+                image: coverUrl,
+                name: song.name,
+                album: song.album,
+                track: song.track,
+                artist: song.artist)
+
+            let amplitudeSong = AmplitudeSong(
+                name: song.name,
+                artist: song.artist,
+                album: song.album,
+                track: "\(song.track)",
+                url: audioFile.absoluteUrl,
+                cover_art_url: coverUrl)
+
+            playlist.append(playlistItem)
+            amplitude.append(amplitudeSong)
+        }
+
+        let footerScript = AudioPlayerScript(items: amplitude).content
+        results.requiredFooters.insert(footerScript)
+        results.requiredHeaders.insert(.audioPlayerCss)
+        results.requiredHeaders.insert(.amplitude)
+
+        results.requiredIcons.formUnion([
+            .audioPlayerClose,
+            .audioPlayerPlaylist,
+            .audioPlayerNext,
+            .audioPlayerPrevious,
+            .audioPlayerPlay,
+            .audioPlayerPause
+        ])
+
+        return AudioPlayer(playingText: titleText, items: playlist).content
+    }
+}

CHDataManagement/Generator/Page Content/ButtonCommand.swift

@@ -0,0 +1,103 @@
+
+struct ButtonCommandProcessor: CommandProcessor {
+
+    let commandType: ShorthandMarkdownKey = .buttons
+
+    let content: Content
+
+    let results: PageGenerationResults
+
+    init(content: Content, results: PageGenerationResults) {
+        self.content = content
+        self.results = results
+    }
+
+    /**
+     Format: `![buttons](<<fileId>,<text>,<download-filename?>;...)`
+     Format: `![buttons](type=<specification>;...)`
+     Types:
+     - Download: `download=<fileId>,<text>,<download-filename?>`
+     - External link: `external=<url>,<text>`
+     - Git: `git=<url>,<text>`
+     - Play: `play-circle=<text>,<click-action>`
+     */
+    func process(_ arguments: [String], markdown: Substring) -> String {
+        let buttons = arguments.compactMap { convert(button: $0, markdown: markdown) }
+        return ContentButtons(items: buttons).content
+    }
+
+    private func convert(button: String, markdown: Substring) -> ContentButtons.Item? {
+        guard let type = PageIcon(rawValue: button.dropAfterFirst("=").trimmed) else {
+            results.invalid(command: commandType, markdown)
+            return nil
+        }
+        let parts = button.dropBeforeFirst("=").components(separatedBy: ",").map { $0.trimmed }
+        switch type {
+        case .buttonDownload:
+            return download(arguments: parts, markdown: markdown)
+        case .buttonGitLink:
+            return link(icon: .buttonGitLink, arguments: parts, markdown: markdown)
+        case .buttonExternalLink:
+            return link(icon: .buttonExternalLink, arguments: parts, markdown: markdown)
+        case .buttonPlay:
+            return play(arguments: parts, markdown: markdown)
+        default:
+            results.invalid(command: commandType, markdown)
+            return nil
+        }
+    }
+
+    private func download(arguments: [String], markdown: Substring) -> ContentButtons.Item? {
+        guard (2...3).contains(arguments.count) else {
+            results.invalid(command: commandType, markdown)
+            return nil
+        }
+        let fileId = arguments[0].trimmed
+        let title = arguments[1].trimmed
+        let downloadName = arguments.count > 2 ? arguments[2].trimmed : nil
+
+        guard let file = content.file(fileId) else {
+            results.missing(file: fileId, markdown: markdown)
+            return nil
+        }
+        results.files.insert(file)
+        results.requiredIcons.insert(.buttonDownload)
+        return ContentButtons.Item(
+            icon: .buttonDownload,
+            filePath: file.absoluteUrl,
+            text: title,
+            downloadFileName: downloadName)
+    }
+
+    private func link(icon: PageIcon, arguments: [String], markdown: Substring) -> ContentButtons.Item? {
+        guard arguments.count == 2 else {
+            results.invalid(command: .buttons, markdown)
+            return nil
+        }
+        let rawUrl = arguments[0].trimmed
+        guard let url = rawUrl.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {
+            results.invalid(command: .buttons, markdown)
+            return nil
+        }
+
+        results.externalLinks.insert(rawUrl)
+        results.requiredIcons.insert(icon)
+
+        let title = arguments[1].trimmed
+
+        return .init(icon: icon, filePath: url, text: title)
+    }
+
+    private func play(arguments: [String], markdown: Substring) -> ContentButtons.Item? {
+        guard arguments.count == 2 else {
+            results.invalid(command: .buttons, markdown)
+            return nil
+        }
+        let text = arguments[0].trimmed
+        let event = arguments[1].trimmed
+
+        results.requiredIcons.insert(.buttonPlay)
+
+        return .init(icon: .buttonPlay, filePath: nil, text: text, onClickText: event)
+    }
+}

CHDataManagement/Generator/Page Content/CommandProcessor.swift

@@ -0,0 +1,9 @@
+
+protocol CommandProcessor {
+
+    var commandType: ShorthandMarkdownKey { get }
+
+    init(content: Content, results: PageGenerationResults)
+
+    func process(_ arguments: [String], markdown: Substring) -> String
+}

CHDataManagement/Generator/Page Content/LabelsCommand.swift

@@ -0,0 +1,30 @@
+
+struct LabelsCommandProcessor: CommandProcessor {
+
+    let commandType: ShorthandMarkdownKey = .labels
+
+    let content: Content
+
+    let results: PageGenerationResults
+
+    init(content: Content, results: PageGenerationResults) {
+        self.content = content
+        self.results = results
+    }
+
+    func process(_ arguments: [String], markdown: Substring) -> String {
+        let labels: [ContentLabel] = arguments.compactMap { arg in
+            let parts = arg.components(separatedBy: "=")
+            guard parts.count == 2 else {
+                results.invalid(command: .labels, markdown)
+                return nil
+            }
+            guard let icon = PageIcon(rawValue: parts[0].trimmed) else {
+                results.invalid(command: .labels, markdown)
+                return nil
+            }
+            return .init(icon: icon, value: parts[1])
+        }
+        return ContentLabels(labels: labels).content
+    }
+}

CHDataManagement/Generator/PageCommandExtractor.swift

@@ -1,20 +1,21 @@
 import Ink
 
+#warning("Remove if unused")
 final class PageCommandExtractor {
 
-    private var occurences: [(full: String, command: String, arguments: [String])] = []
+    private var occurrences: [(full: String, command: String, arguments: [String])] = []
 
-    func findOccurences(of command: ShorthandMarkdownKey, in content: String) -> [(full: String, arguments: [String])] {
-        findOccurences(of: command.rawValue, in: content)
+    func findOccurrences(of command: ShorthandMarkdownKey, in content: String) -> [(full: String, arguments: [String])] {
+        findOccurrences(of: command.rawValue, in: content)
     }
 
-    func findOccurences(of command: String, in content: String) -> [(full: String, arguments: [String])] {
+    func findOccurrences(of command: String, in content: String) -> [(full: String, arguments: [String])] {
         let parser = MarkdownParser(modifiers: [
             Modifier(target: .images, closure: processMarkdownImage),
         ])
         _ = parser.html(from: content)
 
-        return occurences
+        return occurrences
             .filter { $0.command == command }
             .map { ($0.full, $0.arguments) }
     }
@@ -25,7 +26,7 @@ final class PageCommandExtractor {
 
 
         let command = markdown.between("![", and: "]").trimmed
-        occurences.append((full: String(markdown), command: command, arguments: arguments))
+        occurrences.append((full: String(markdown), command: command, arguments: arguments))
         return ""
     }
 }

CHDataManagement/Generator/PageContentAnomaly.swift

@@ -1,12 +1,10 @@
 
-
 enum PageContentAnomaly {
     case failedToLoadContent(Error)
-    case missingFile(String)
-    case missingPage(String)
-    case missingTag(String)
-    case unknownCommand(String)
-    case invalidCommandArguments(command: ShorthandMarkdownKey, arguments: [String])
+    case missingFile(file: String, markdown: String)
+    case missingPage(page: String, markdown: String)
+    case missingTag(tag: String, markdown: String)
+    case invalidCommand(command: ShorthandMarkdownKey?, markdown: String)
 }
 
 extension PageContentAnomaly: Identifiable {
@@ -15,20 +13,32 @@ extension PageContentAnomaly: Identifiable {
         switch self {
         case .failedToLoadContent:
             return "load-failed"
-        case .missingFile(let string):
+        case .missingFile(let string, _):
             return "missing-file-\(string)"
-        case .missingPage(let string):
+        case .missingPage(let string, _):
             return "missing-page-\(string)"
-        case .missingTag(let string):
+        case .missingTag(let string, _):
             return "missing-tag-\(string)"
-        case .unknownCommand(let string):
-            return "unknown-command-\(string)"
-        case .invalidCommandArguments(let command, let arguments):
-            return "invalid-arguments-\(command)-\(arguments.joined(separator: "-"))"
+        case .invalidCommand(_, let markdown):
+            return "invalid-command-\(markdown)"
         }
     }
 }
 
+extension PageContentAnomaly: Equatable {
+
+    static func == (lhs: PageContentAnomaly, rhs: PageContentAnomaly) -> Bool {
+        lhs.id == rhs.id
+    }
+}
+
+extension PageContentAnomaly: Hashable {
+
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(id)
+    }
+}
+
 extension PageContentAnomaly {
 
     enum Severity: String, CaseIterable {
@@ -40,7 +50,7 @@ extension PageContentAnomaly {
         switch self {
         case .failedToLoadContent:
             return .error
-        case .missingFile, .missingPage, .missingTag, .unknownCommand, .invalidCommandArguments:
+        case .missingFile, .missingPage, .missingTag, .invalidCommand:
             return .warning
         }
     }
@@ -52,16 +62,14 @@ extension PageContentAnomaly: CustomStringConvertible {
         switch self {
         case .failedToLoadContent(let error):
             return "Failed to load content: \(error)"
-        case .missingFile(let string):
-            return "Missing file \(string)"
-        case .missingPage(let string):
-            return "Missing page \(string)"
-        case .missingTag(let string):
-            return "Missing tag \(string)"
-        case .unknownCommand(let string):
-            return "Unknown command \(string)"
-        case .invalidCommandArguments(let command, let arguments):
-            return "Invalid command arguments for \(command): \(arguments)"
+        case .missingFile(let string, _):
+            return "Missing file: \(string)"
+        case .missingPage(let string, _):
+            return "Missing page: \(string)"
+        case .missingTag(let string, _):
+            return "Missing tag: \(string)"
+        case .invalidCommand(_, let markdown):
+            return "Invalid command: \(markdown)"
         }
     }
 }

CHDataManagement/Generator/PageContentGenerator.swift

@@ -1,6 +1,7 @@
 import Foundation
 import Ink
 import Splash
+import SwiftSoup
 
 typealias VideoSource = (url: String, type: VideoFileType)
 
@@ -18,6 +19,12 @@ final class PageContentParser {
 
     private let content: Content
 
+    private let buttonHandler: ButtonCommandProcessor
+
+    private let labelHandler: LabelsCommandProcessor
+
+    private let audioPlayer: AudioPlayerCommandProcessor
+
     let language: ContentLanguage
 
     var largeImageWidth: Int {
@@ -31,6 +38,9 @@ final class PageContentParser {
     init(content: Content, language: ContentLanguage) {
         self.content = content
         self.language = language
+        self.buttonHandler = .init(content: content, results: results)
+        self.labelHandler = .init(content: content, results: results)
+        self.audioPlayer = .init(content: content, results: results)
     }
 
     func requestImages(_ generator: ImageGenerator) {
@@ -77,7 +87,7 @@ final class PageContentParser {
         if file.hasPrefix(tagLinkMarker) {
             return handleTagLink(file: file, html: html, markdown: markdown)
         }
-        #warning("Check existence of linked file")
+        results.externalLinks.insert(file)
         return html
     }
 
@@ -86,12 +96,12 @@ final class PageContentParser {
         let textToChange = file.dropAfterFirst("#")
         let pageId = textToChange.replacingOccurrences(of: pageLinkMarker, with: "")
         guard let page = content.page(pageId) else {
-            results.missingPages.insert(pageId)
+            results.missing(page: pageId, markdown: markdown)
             // Remove link since the page can't be found
             return markdown.between("[", and: "]")
         }
         results.linkedPages.insert(page)
-        let pagePath = content.absoluteUrlToPage(page, language: language)
+        let pagePath = page.absoluteUrl(for: language)
         return html.replacingOccurrences(of: textToChange, with: pagePath)
     }
 
@@ -100,7 +110,7 @@ final class PageContentParser {
         let textToChange = file.dropAfterFirst("#")
         let tagId = textToChange.replacingOccurrences(of: tagLinkMarker, with: "")
         guard let tag = content.tag(tagId) else {
-            results.missingTags.insert(tagId)
+            results.missing(tag: tagId, markdown: markdown)
             // Remove link since the tag can't be found
             return markdown.between("[", and: "]")
         }
@@ -109,10 +119,71 @@ final class PageContentParser {
         return html.replacingOccurrences(of: textToChange, with: tagPath)
     }
 
-    private func handleHTML(html: String, markdown: Substring) -> String {
+    private func handleHTML(_: String, markdown: Substring) -> String {
+        let result = String(markdown)
         #warning("Check HTML code in markdown for required resources")
+        findImages(in: result)
+        findLinks(in: result)
+        findSourceSets(in: result)
         // Things to check: <img src=  <a href= <source>
-        return html
+        return result
+    }
+
+    private func findImages(in markdown: String) {
+        do {
+            // Parse the HTML string
+            let document = try SwiftSoup.parse(markdown)
+
+            // Select all 'img' elements
+            let imgElements = try document.select("img")
+
+            // Extract the 'src' attributes from each 'img' element
+            let srcAttributes = try imgElements.array().compactMap { try $0.attr("src") }
+
+            for src in srcAttributes {
+                print("Found image in html: \(src)")
+            }
+        } catch {
+            print("Error parsing HTML: \(error)")
+        }
+    }
+
+    private func findLinks(in markdown: String) {
+        do {
+            // Parse the HTML string
+            let document = try SwiftSoup.parse(markdown)
+
+            // Select all 'img' elements
+            let linkElements = try document.select("a")
+
+            // Extract the 'src' attributes from each 'img' element
+            let srcAttributes = try linkElements.array().compactMap { try $0.attr("href") }
+
+            for src in srcAttributes {
+                print("Found link in html: \(src)")
+            }
+        } catch {
+            print("Error parsing HTML: \(error)")
+        }
+    }
+
+    private func findSourceSets(in markdown: String) {
+        do {
+            // Parse the HTML string
+            let document = try SwiftSoup.parse(markdown)
+
+            // Select all 'img' elements
+            let linkElements = try document.select("source")
+
+            // Extract the 'src' attributes from each 'img' element
+            let srcAttributes = try linkElements.array().compactMap { try $0.attr("srcset") }
+
+            for src in srcAttributes {
+                print("Found source set in html: \(src)")
+            }
+        } catch {
+            print("Error parsing HTML: \(error)")
+        }
     }
 
     /**
@@ -151,40 +222,38 @@ final class PageContentParser {
 
         let rawCommand = percentDecoded(markdown.between("![", and: "]").trimmed)
         guard rawCommand != "" else {
-            return handleImage(arguments)
+            return handleImage(arguments, markdown: markdown)
         }
 
         guard let command = ShorthandMarkdownKey(rawValue: rawCommand) else {
             // Treat unknown commands as normal links
-            results.unknownCommands.append(rawCommand)
+            results.invalid(command: nil, markdown)
             return html
         }
 
         switch command {
         case .image:
-            return handleImage(arguments)
-        case .hikingStatistics:
-            return handleHikingStatistics(arguments)
-        case .downloadButtons:
-            return handleDownloadButtons(arguments)
+            return handleImage(arguments, markdown: markdown)
+        case .labels:
+            return labelHandler.process(arguments, markdown: markdown)
+        case .buttons:
+            return buttonHandler.process(arguments, markdown: markdown)
         case .video:
-            return handleVideo(arguments)
-        case .externalLink:
-            return handleExternalButtons(arguments)
-        case .gitLink:
-            return handleGitButtons(arguments)
+            return handleVideo(arguments, markdown: markdown)
         case .pageLink:
-            return handlePageLink(arguments)
+            return handlePageLink(arguments, markdown: markdown)
         case .includedHtml:
-            return handleExternalHtml(arguments)
+            return handleExternalHtml(arguments, markdown: markdown)
         case .box:
-            return handleSimpleBox(arguments)
+            return handleSimpleBox(arguments, markdown: markdown)
         case .model:
-            return handleModel(arguments)
+            return handleModel(arguments, markdown: markdown)
         case .svg:
-            return handleSvg(arguments)
+            return handleSvg(arguments, markdown: markdown)
+        case .audioPlayer:
+            return audioPlayer.process(arguments, markdown: markdown)
         default:
-            results.unknownCommands.append(command.rawValue)
+            results.invalid(command: nil, markdown)
             return ""
         }
     }
@@ -192,15 +261,15 @@ final class PageContentParser {
     /**
      Format: `[image](<imageId>;<caption?>]`
      */
-    private func handleImage(_ arguments: [String]) -> String {
+    private func handleImage(_ arguments: [String], markdown: Substring) -> String {
         guard (1...2).contains(arguments.count) else {
-            results.invalidCommandArguments.append((.image , arguments))
+            results.invalid(command: .image, markdown)
             return ""
         }
         let imageId = arguments[0]
 
         guard let image = content.image(imageId) else {
-            results.missingFiles.insert(imageId)
+            results.missing(file: imageId, markdown: markdown)
             return ""
         }
         results.files.insert(image)
@@ -208,7 +277,7 @@ final class PageContentParser {
         let caption = arguments.count == 2 ? arguments[1] : nil
         let altText = image.getDescription(for: language)
 
-        let path = content.absoluteUrlToFile(image)
+        let path = image.absoluteUrl
 
         guard !image.type.isSvg else {
             return SvgImage(imagePath: path, altText: altText).content
@@ -235,170 +304,80 @@ final class PageContentParser {
             caption: caption).content
     }
 
-    /**
-     Format: `![hiking-stats](<time>;<elevation-up>;<elevation-down>;<distance>;<calories>)`
-     */
-    private func handleHikingStatistics(_ arguments: [String]) -> String {
-        #warning("Make statistics more generic using key-value pairs")
-        guard (1...5).contains(arguments.count) else {
-            results.invalidCommandArguments.append((.hikingStatistics, arguments))
-            return ""
-        }
-
-        let time = arguments[0].trimmed
-        let elevationUp = arguments.count > 1 ? arguments[1].trimmed : nil
-        let elevationDown = arguments.count > 2 ? arguments[2].trimmed : nil
-        let distance = arguments.count > 3 ? arguments[3].trimmed : nil
-        let calories = arguments.count > 4 ? arguments[4].trimmed : nil
-
-        return HikingStatistics(
-            time: time,
-            elevationUp: elevationUp,
-            elevationDown: elevationDown,
-            distance: distance,
-            calories: calories)
-        .content
-    }
-
-    /**
-     Format: `![download](<<fileId>,<text>,<download-filename?>;...)`
-     */
-    private func handleDownloadButtons(_ arguments: [String]) -> String {
-        let buttons = arguments.compactMap(convertButton)
-        return ContentButtons(items: buttons).content
-    }
-
-    private func convertButton(definition button: String) -> ContentButtons.Item? {
-        let parts = button.components(separatedBy: ",")
-        guard (2...3).contains(parts.count) else {
-            results.invalidCommandArguments.append((.downloadButtons, parts))
-            return nil
-        }
-        let fileId = parts[0].trimmed
-        let title = parts[1].trimmed
-        let downloadName = parts.count > 2 ? parts[2].trimmed : nil
-
-        guard let file = content.file(id: fileId) else {
-            results.missingFiles.insert(fileId)
-            return nil
-        }
-        results.files.insert(file)
-        let filePath = content.absoluteUrlToFile(file)
-        return ContentButtons.Item(icon: .download, filePath: filePath, text: title, downloadFileName: downloadName)
-    }
-
     /**
      Format: `![video](<fileId>;<option1...>]`
      */
-    private func handleVideo(_ arguments: [String]) -> String {
+    private func handleVideo(_ arguments: [String], markdown: Substring) -> String {
         guard arguments.count >= 1 else {
-            results.invalidCommandArguments.append((.video, arguments))
+            results.invalid(command: .video, markdown)
             return ""
         }
         let fileId = arguments[0].trimmed
 
-        let options = arguments.dropFirst().compactMap(convertVideoOption)
+        let options = arguments.dropFirst().compactMap { convertVideoOption($0, markdown: markdown) }
 
-        guard let file = content.file(id: fileId) else {
-            results.missingFiles.insert(fileId)
+        guard let file = content.file(fileId) else {
+            results.missing(file: fileId, markdown: markdown)
             return ""
         }
         results.files.insert(file)
 
         guard let videoType = file.type.videoType?.htmlType else {
-            results.invalidCommandArguments.append((.video, arguments))
+            results.invalid(command: .video, markdown)
             return ""
         }
 
-        let filePath = content.absoluteUrlToFile(file)
         return ContentPageVideo(
-            filePath: filePath,
+            filePath: file.absoluteUrl,
             videoType: videoType,
             options: options)
         .content
     }
 
-    private func convertVideoOption(_ videoOption: String) -> VideoOption? {
+    private func convertVideoOption(_ videoOption: String, markdown: Substring) -> VideoOption? {
         guard let optionText = videoOption.trimmed.nonEmpty else {
             return nil
         }
         guard let option = VideoOption(rawValue: optionText) else {
-            results.invalidCommandArguments.append((.video, [optionText]))
+            results.invalid(command: .video, markdown)
             return nil
         }
         if case let .poster(imageId) = option {
             if let image = content.image(imageId) {
                 results.files.insert(image)
-                let link = content.absoluteUrlToFile(image)
                 let width = 2*thumbnailWidth
-                let fullLink = WebsiteImage.imagePath(source: link, width: width, height: width)
+                let fullLink = WebsiteImage.imagePath(source: image.absoluteUrl, width: width, height: width)
                 return .poster(image: fullLink)
             } else {
-                results.missingFiles.insert(imageId)
+                results.missing(file: imageId, markdown: markdown)
                 return nil // Image file not present, so skip the option
             }
         }
         if case let .src(videoId) = option {
             if let video = content.video(videoId) {
                 results.files.insert(video)
-                let link = content.absoluteUrlToFile(video)
+                let link = video.absoluteUrl
                 // TODO: Set correct video path?
                 return .src(link)
             } else {
-                results.missingFiles.insert(videoId)
+                results.missing(file: videoId, markdown: markdown)
                 return nil // Video file not present, so skip the option
             }
         }
         return option
     }
 
-    private func handleExternalButtons(_ arguments: [String]) -> String {
-        // ![external](<<url>;<text>...>
-        handleButtons(icon: .externalLink, arguments: arguments)
-    }
-
-    private func handleGitButtons(_ arguments: [String]) -> String {
-        // ![git](<<url>;<text>...>
-        handleButtons(icon: .gitLink, arguments: arguments)
-    }
-
-    private func handleButtons(icon: PageIcon, arguments: [String]) -> String {
-        guard arguments.count >= 1 else {
-            results.invalidCommandArguments.append((.externalLink, arguments))
-            return ""
-        }
-        let buttons: [ContentButtons.Item] = arguments.compactMap { button in
-            let parts = button.components(separatedBy: ",")
-            guard parts.count == 2 else {
-                results.invalidCommandArguments.append((.externalLink, parts))
-                return nil
-            }
-            let rawUrl = parts[0].trimmed
-            guard let url = rawUrl.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {
-                results.invalidCommandArguments.append((.externalLink, parts))
-                return nil
-            }
-            let title = parts[1].trimmed
-
-            return .init(
-                icon: icon,
-                filePath: url,
-                text: title)
-        }
-        return ContentButtons(items: buttons).content
-    }
-
     /**
      Format: `![html](<fileId>)`
      */
-    private func handleExternalHtml(_ arguments: [String]) -> String {
+    private func handleExternalHtml(_ arguments: [String], markdown: Substring) -> String {
         guard arguments.count == 1 else {
-            results.invalidCommandArguments.append((.includedHtml, arguments))
+            results.invalid(command: .includedHtml, markdown)
             return ""
         }
         let fileId = arguments[0]
-        guard let file = content.file(id: fileId) else {
-            results.missingFiles.insert(fileId)
+        guard let file = content.file(fileId) else {
+            results.missing(file: fileId, markdown: markdown)
             return ""
         }
         return file.textContent()
@@ -407,9 +386,9 @@ final class PageContentParser {
     /**
      Format: `![box](<title>;<body>)`
      */
-    private func handleSimpleBox(_ arguments: [String]) -> String {
+    private func handleSimpleBox(_ arguments: [String], markdown: Substring) -> String {
         guard arguments.count > 1 else {
-            results.invalidCommandArguments.append((.box, arguments))
+            results.invalid(command: .box, markdown)
             return ""
         }
         let title = arguments[0]
@@ -420,15 +399,15 @@ final class PageContentParser {
     /**
      Format: `![page](<pageId>)`
      */
-    private func handlePageLink(_ arguments: [String]) -> String {
+    private func handlePageLink(_ arguments: [String], markdown: Substring) -> String {
         guard arguments.count == 1 else {
-            results.invalidCommandArguments.append((.pageLink, arguments))
+            results.invalid(command: .pageLink, markdown)
             return ""
         }
         let pageId = arguments[0]
 
         guard let page = content.page(pageId) else {
-            results.missingPages.insert(pageId)
+            results.missing(page: pageId, markdown: markdown)
             return ""
         }
         guard !page.isDraft else {
@@ -437,7 +416,7 @@ final class PageContentParser {
         }
 
         let localized = page.localized(in: language)
-        let url = content.absoluteUrlToPage(page, language: language)
+        let url = page.absoluteUrl(for: language)
         let title = localized.linkPreviewTitle ?? localized.title
         let description = localized.linkPreviewDescription ?? ""
 
@@ -447,7 +426,7 @@ final class PageContentParser {
             results.imagesToGenerate.insert(.init(size: size, image: image))
 
             return RelatedPageLink.Image(
-                url: content.absoluteUrlToFile(image),
+                url: image.absoluteUrl,
                 description: image.getDescription(for: language),
                 size: size)
         }
@@ -463,32 +442,31 @@ final class PageContentParser {
     /**
      Format: `![model](<file>)`
      */
-    private func handleModel(_ arguments: [String]) -> String {
+    private func handleModel(_ arguments: [String], markdown: Substring) -> String {
         guard arguments.count == 1 else {
-            results.invalidCommandArguments.append((.model, arguments))
+            results.invalid(command: .model, markdown)
             return ""
         }
         let fileId = arguments[0]
         guard fileId.hasSuffix(".glb") else {
-            results.invalidCommandArguments.append((.model, ["\(fileId) is not a .glb file"]))
+            results.invalid(command: .model, markdown)
             return ""
         }
 
-        guard let file = content.file(id: fileId) else {
-            results.missingFiles.insert(fileId)
+        guard let file = content.file(fileId) else {
+            results.missing(file: fileId, markdown: markdown)
             return ""
         }
         results.files.insert(file)
         results.requiredHeaders.insert(.modelViewer)
 
-        let path = content.absoluteUrlToFile(file)
         let description = file.getDescription(for: language)
-        return ModelViewer(file: path, description: description).content
+        return ModelViewer(file: file.absoluteUrl, description: description).content
     }
 
-    private func handleSvg(_ arguments: [String]) -> String {
+    private func handleSvg(_ arguments: [String], markdown: Substring) -> String {
         guard arguments.count == 5 else {
-            results.invalidCommandArguments.append((.svg, arguments))
+            results.invalid(command: .svg, markdown)
             return ""
         }
 
@@ -496,26 +474,24 @@ final class PageContentParser {
               let y = Int(arguments[2]),
               let partWidth = Int(arguments[3]),
               let partHeight = Int(arguments[4]) else {
-            results.invalidCommandArguments.append((.svg, arguments))
+            results.invalid(command: .svg, markdown)
             return ""
         }
 
         let imageId = arguments[0]
 
         guard let image = content.image(imageId) else {
-            results.missingFiles.insert(imageId)
+            results.missing(file: imageId, markdown: markdown)
             return ""
         }
         guard case .image(let imageType) = image.type,
               imageType == .svg else {
-            results.invalidCommandArguments.append((.svg, arguments))
+            results.invalid(command: .svg, markdown)
             return ""
         }
 
-        let path = content.absoluteUrlToFile(image)
-
         return PartialSvgImage(
-            imagePath: path,
+            imagePath: image.absoluteUrl,
             altText: image.getDescription(for: language),
             x: x,
             y: y,
@@ -523,7 +499,6 @@ final class PageContentParser {
             height: partHeight)
         .content
     }
-
 }
 
 /*

CHDataManagement/Generator/PageGenerationResults.swift

@@ -23,6 +23,9 @@ final class PageGenerationResults: ObservableObject {
     @Published
     var linkedTags: Set<Tag> = []
 
+    @Published
+    var externalLinks: Set<String> = []
+
     @Published
     var files: Set<FileResource> = []
 
@@ -39,10 +42,7 @@ final class PageGenerationResults: ObservableObject {
     var missingTags: Set<String> = []
 
     @Published
-    var unknownCommands: [String] = []
-
-    @Published
-    var invalidCommandArguments: [(command: ShorthandMarkdownKey, arguments: [String])] = []
+    var invalidCommands: [(command: ShorthandMarkdownKey?, markdown: String)] = []
 
     @Published
     var requiredHeaders: RequiredHeaders = []
@@ -50,26 +50,45 @@ final class PageGenerationResults: ObservableObject {
     @Published
     var requiredFooters: Set<String> = []
 
+    @Published
+    var requiredIcons: Set<PageIcon> = []
+
+    @Published
+    var issues: Set<PageContentAnomaly> = []
+
     func reset() {
         linkedPages = []
         linkedTags = []
+        externalLinks = []
         files = []
         imagesToGenerate = []
         missingPages = []
         missingFiles = []
         missingTags = []
-        unknownCommands = []
-        invalidCommandArguments = []
+        invalidCommands = []
         requiredHeaders = []
         requiredFooters = []
+        requiredIcons = []
+        issues = []
     }
 
-    var convertedWarnings: [PageContentAnomaly] {
-        var result = [PageContentAnomaly]()
-        result += missingPages.map { .missingPage($0) }
-        result += missingFiles.map { .missingFile($0) }
-        result += unknownCommands.map { .unknownCommand($0) }
-        result += invalidCommandArguments.map { .invalidCommandArguments(command: $0.command, arguments: $0.arguments) }
-        return result
+    func invalid(command: ShorthandMarkdownKey?, _ markdown: Substring) {
+        invalidCommands.append((command, String(markdown)))
+        issues.insert(.invalidCommand(command: command, markdown: String(markdown)))
+    }
+
+    func missing(page: String, markdown: Substring) {
+        missingPages.insert(page)
+        issues.insert(.missingPage(page: page, markdown: String(markdown)))
+    }
+
+    func missing(tag: String, markdown: Substring) {
+        missingTags.insert(tag)
+        issues.insert(.missingTag(tag: tag, markdown: String(markdown)))
+    }
+
+    func missing(file: String, markdown: Substring) {
+        missingFiles.insert(file)
+        issues.insert(.missingFile(file: file, markdown: String(markdown)))
     }
 }

CHDataManagement/Generator/PageGenerator.swift

@@ -43,7 +43,8 @@ final class PageGenerator {
             navigationBarLinks: navigationBarLinks,
             pageContent: pageContent,
             headers: headers.content,
-            footers: contentGenerator.results.requiredFooters.sorted())
+            footers: contentGenerator.results.requiredFooters.sorted(),
+            icons: contentGenerator.results.requiredIcons)
             .content
 
         return (fullPage, contentGenerator.results)

CHDataManagement/Generator/PostListPageGenerator.swift

@@ -62,7 +62,7 @@ final class PostListPageGenerator {
 
             let linkUrl = post.linkedPage.map {
                 FeedEntryData.Link(
-                    url: content.absoluteUrlToPage($0, language: language),
+                    url: $0.absoluteUrl(for: language),
                     text: language == .english ? "View" : "Anzeigen") // TODO: Add to settings
             }
 
@@ -104,7 +104,7 @@ final class PostListPageGenerator {
             maxWidth: mainContentMaximumWidth,
             maxHeight: mainContentMaximumWidth)
         return .init(
-            rawImagePath: content.absoluteUrlToFile(image),
+            rawImagePath: image.absoluteUrl,
             width: Int(mainContentMaximumWidth),
             height: Int(mainContentMaximumWidth),
             altText: image.getDescription(for: language))

CHDataManagement/Generator/RequiredHeaders.swift

@@ -5,10 +5,16 @@ enum HeaderFile: String {
     
     case modelViewer = "model-viewer.min.js"
 
+    case audioPlayerCss = "audio-player.css"
+
+    case amplitude = "amplitude.min.js"
+
     var asModule: Bool {
         switch self {
         case .codeHightlighting: return false
         case .modelViewer: return true
+        case .amplitude: return false
+        case .audioPlayerCss: return false
         }
     }
 }

CHDataManagement/Generator/ShorthandMarkdownKey.swift

@@ -13,20 +13,17 @@ enum ShorthandMarkdownKey: String {
     /// Format:  `![image](<imageId>;<caption?>]`
     case image
 
-    /// Statistics about hiking
-    /// Format: `![hiking-stats](<`
-    case hikingStatistics = "hiking-stats"
+    /// Labels with an icon and a value
+    /// Format: `![labels](<icon=value>...)`
+    case labels
 
     /// A video
     /// Format: `![video](<fileId>;<option1...>]`
     case video
 
-    /// An SVG image
-    /// Format: `![svg](<fileId>;<<x>;<y>;<width>;<height>?>)`
-
     /// A variable number of download buttons for file downloads
-    /// Format: `[download](<<fileId>,<text>,<download-filename?>;...)`
-    case downloadButtons = "download"
+    /// Format: `[buttons](type=<<fileId>,<text>,<download-filename?>;...)`
+    case buttons
 
     /// A box with a title and content
     /// Format: `![box](<title>;<body>)`
@@ -40,20 +37,16 @@ enum ShorthandMarkdownKey: String {
     /// Format: `![page](<pageId>)`
     case pageLink = "page"
 
-    /// A large button to an external page.
-    /// Format: `![external](<<url>;<text>...>`
-    case externalLink = "external"
-
-    /// A large button to a git/github page
-    /// Format: `![git](<<url>;<text>...>`
-    case gitLink = "git"
-
     /// Additional HTML code include verbatim into the page.
     /// Format: `![html](<fileId>)`
     case includedHtml = "html"
 
     /// SVG Image showing only a part of the image
-    /// Format `![svg](<fileId>;`
+    /// Format `![svg](<fileId>;<<x>;<y>;<width>;<height>>?)`
     case svg
 
+    /// A player to play audio files
+    /// Format: `![audio-player](<fileId>;<text>)`
+    case audioPlayer = "audio-player"
+
 }