splash/Sources/Splash/Output/AttributedStringOutputFormat.swift

/**
 *  Splash
 *  Copyright (c) John Sundell 2018
 *  MIT license - see LICENSE.md
 */

#if os(macOS)

import Cocoa

/// Output format to use to generate an NSAttributedString from the
/// highlighted code. A `Theme` is used to determine what fonts and
/// colors to use for the various tokens.
public struct AttributedStringOutputFormat: OutputFormat {
    public var theme: Theme

    public init(theme: Theme) {
        self.theme = theme
    }

    public func makeBuilder() -> Builder {
        return Builder(theme: theme)
    }
}

public extension AttributedStringOutputFormat {
    struct Builder: OutputBuilder {
        private let theme: Theme
        private lazy var font = loadFont()
        private var string = NSMutableAttributedString()

        fileprivate init(theme: Theme) {
            self.theme = theme
        }

        public mutating func addToken(_ token: String, ofType type: TokenType) {
            let color = theme.tokenColors[type] ?? Color(red: 1, green: 1, blue: 1)
            string.append(token, font: font, color: color)
        }

        public mutating func addPlainText(_ text: String) {
            string.append(text, font: font, color: theme.plainTextColor)
        }

        public mutating func addWhitespace(_ whitespace: String) {
            let color = Color(red: 1, green: 1, blue: 1)
            string.append(whitespace, font: font, color: color)
        }

        public func build() -> NSAttributedString {
            return NSAttributedString(attributedString: string)
        }

        private mutating func loadFont() -> NSFont {
            let size = CGFloat(theme.font.size)

            switch theme.font.resource {
            case .system:
                return .defaultFont(ofSize: size)
            case .path(let path):
                guard let font = NSFont.loaded(from: path, size: size) else {
                    return .defaultFont(ofSize: size)
                }

                return font
            }
        }
    }
}

private extension NSMutableAttributedString {
    func append(_ string: String, font: NSFont, color: Color) {
        let color = NSColor(
            red: CGFloat(color.red),
            green: CGFloat(color.green),
            blue: CGFloat(color.blue),
            alpha: CGFloat(color.alpha)
        )

        let attributedString = NSAttributedString(string: string, attributes: [
            .foregroundColor: color,
            .font: font
        ])

        append(attributedString)
    }
}

private extension NSFont {
    static func loaded(from path: String, size: CGFloat) -> NSFont? {
        let url = CFURLCreateWithFileSystemPath(
            kCFAllocatorDefault,
            path as CFString,
            .cfurlposixPathStyle,
            false
        )

        guard let font = url.flatMap(CGDataProvider.init).flatMap(CGFont.init) else {
            return nil
        }

        return CTFontCreateWithGraphicsFont(font, size, nil, nil)
    }

    static func defaultFont(ofSize size: CGFloat) -> NSFont {
        guard let courier = loaded(from: "/Library/Fonts/Courier New.ttf", size: size) else {
            return .systemFont(ofSize: size)
        }

        return courier
    }
}

#endif