HTMLKit/Sources/HTMLKitVapor/Extensions/Vapor+HTMLKit.swift at 58ac8ed39cbc12c87e4b4925a96accc556c61f03 · vapor-community/HTMLKit · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
/*
 Abstract:
 The file contains the extensions of some Vapor directives.
 */

import HTMLKit
import Vapor

extension Application {

    /// Access to the vapor provider
    public var htmlkit: HtmlKit  {
        return .init(application: self)
    }

    /// The vapor provider
    public struct HtmlKit {

        public var security: HTMLKit.Security {

            get {
                self.configuration.security
            }

            nonmutating set {
                self.configuration.security = newValue
            }
        }

        public var environment: HTMLKit.Environment {

            get {
                self.configuration.environment
            }

            nonmutating set {
                self.configuration.environment = newValue
            }
        }

        public var localization: HTMLKit.Localization {

            get {
                self.configuration.localization
            }

            nonmutating set {
                self.configuration.localization = newValue
            }
        }

        public var features: HTMLKit.Features {

            get {
                self.configuration.features
            }

            nonmutating set {
                self.configuration.features = newValue
            }
        }

        internal struct ConfigurationKey: StorageKey {

            public typealias Value = Configuration
        }

        /// The configuration storage
        internal var configuration: Configuration {

            if let configuration = self.application.storage[ConfigurationKey.self] {
                return configuration
            }

            let configuration = Configuration()

            self.application.storage[ConfigurationKey.self] = configuration

            return configuration
        }

        /// The view renderer
        internal var renderer: ViewRenderer {

            return .init(eventLoop: application.eventLoopGroup.next(), configuration: configuration, logger: application.logger)
        }

        /// The application dependency
        internal let application: Application

        /// Creates the provider
        public init(application: Application) {

            self.application = application
        }
    }
}

extension Request {

    /// The accept language header of the request
    private var acceptLanguage: String? {

        if let languageHeader = self.headers.first(name: .acceptLanguage) {
            return languageHeader.components(separatedBy: ",").first
        }

        return nil
    }

    /// Access to the view renderer
    public var htmlkit: ViewRenderer {

        if let acceptLanguage = self.acceptLanguage {
            self.application.htmlkit.environment.locale = HTMLKit.Locale(tag: acceptLanguage)
        }

        return .init(eventLoop: self.eventLoop, configuration: self.application.htmlkit.configuration, logger: self.logger)
    }
}

extension HTMLKit.Renderer.Errors: AbortError {

    @_implements(AbortError, reason)
    public var abortReason: String { self.description }

    public var status: HTTPResponseStatus { .internalServerError }
}

extension HTMLKit.Renderer.Errors: DebuggableError {

    @_implements(DebuggableError, reason)
    public var debuggableReason: String {  self.description }
}

extension HTMLKit.Localization.Errors: AbortError {

    @_implements(AbortError, reason)
    public var abortReason: String { self.description }

    public var status: HTTPResponseStatus { .internalServerError }
}

extension HTMLKit.Localization.Errors: DebuggableError {

    @_implements(DebuggableError, reason)
    public var debuggableReason: String { self.description }
}