] = []) -> Self {
+ Document(elements: elements)
+ }
+}
+
+extension Document: Renderable {
+ public func render(indentedBy indentationKind: Indentation.Kind?) -> String {
+ let indentation = indentationKind.map(Indentation.init)
+ let html = elements.map { $0.render(indentedBy: indentation) }
+ return html.joined(separator: indentationKind == nil ? "" : "\n")
+ }
+}
diff --git a/Sources/Plot/API/DocumentEncoding.swift b/Sources/Plot/API/DocumentEncoding.swift
new file mode 100644
index 0000000..54b896f
--- /dev/null
+++ b/Sources/Plot/API/DocumentEncoding.swift
@@ -0,0 +1,13 @@
+/**
+* Plot
+* Copyright (c) John Sundell 2019
+* MIT license, see LICENSE file for details
+*/
+
+import Foundation
+
+/// Enum defining possible encodings to use when rendering a document
+public enum DocumentEncoding: String {
+ /// Use the UTF-8 Unicode encoding
+ case utf8 = "UTF-8"
+}
diff --git a/Sources/Plot/API/Element.swift b/Sources/Plot/API/Element.swift
new file mode 100644
index 0000000..f3b7f4d
--- /dev/null
+++ b/Sources/Plot/API/Element.swift
@@ -0,0 +1,65 @@
+/**
+* Plot
+* Copyright (c) John Sundell 2019
+* MIT license, see LICENSE file for details
+*/
+
+import Foundation
+
+/// A representation of an element within a document, such as an HTML or XML tag.
+/// You normally don't construct `Element` values manually, but rather use Plot's
+/// various DSL APIs to create them, for example by creating a `` tag using
+/// `.body()`, or a `` tag using `.p()`.
+public struct Element {
+ /// The name of the element
+ public var name: String
+ /// How the element is closed, for example if it's self-closing or if it can
+ /// contain child elements.
+ public var closingMode: ClosingMode = .standard
+
+ internal var nodes: [AnyNode]
+ internal var paddingCharacter: Character? = nil
+}
+
+public extension Element {
+ /// Enum defining how a given element should be closed
+ enum ClosingMode {
+ /// The standard (default) closing mode, which creates a pair of opening
+ /// and closing tags, for example ``.
+ case standard
+ /// For elements that are never closed, for example the leading declaration
+ /// tags found at the top of XML documents.
+ case neverClosed
+ /// For elements that close themselves, for example `]) -> Element {
+ Element(name: name, nodes: nodes)
+ }
+
+ /// Create a custom self-closed element with a given name and array of attributes.
+ /// - parameter name: The name of the element to create.
+ /// - parameter attributes The attributes to add to the element.
+ static func selfClosed(named name: String,
+ attributes: [Attribute]) -> Element {
+ Element(name: name, closingMode: .selfClosing, nodes: attributes.asNodes())
+ }
+}
+
+extension Element: Renderable {
+ public func render(indentedBy indentation: Indentation?) -> String {
+ let renderer = ElementRenderer(
+ elementName: name,
+ paddingCharacter: paddingCharacter,
+ indentation: indentation
+ )
+
+ nodes.forEach { $0.render(into: renderer) }
+
+ return renderer.render(withClosingMode: closingMode)
+ }
+}
diff --git a/Sources/Plot/API/HTML.swift b/Sources/Plot/API/HTML.swift
new file mode 100644
index 0000000..a27aa39
--- /dev/null
+++ b/Sources/Plot/API/HTML.swift
@@ -0,0 +1,136 @@
+/**
+* Plot
+* Copyright (c) John Sundell 2019
+* MIT license, see LICENSE file for details
+*/
+
+import Foundation
+
+/// A representation of an HTML document. Create an instance of this
+/// type to build a web page using Plot's type-safe DSL, and then
+/// call the `render()` method to turn it into an HTML string.
+public struct HTML: DocumentFormat {
+ private let document: Document
+
+ /// Create an HTML document with a collection of nodes that make
+ /// up its elements and attributes. Start by specifying its root
+ /// nodes, such as `.head()` and `.body()`, and then create any
+ /// sort of hierarchy of elements and attributes from there.
+ /// - parameter nodes: The root nodes of the document, which will
+ /// be placed inside of an `` element.
+ public init(_ nodes: Node...) {
+ document = Document(elements: [
+ .doctype("html"),
+ .html(.group(nodes))
+ ])
+ }
+}
+
+extension HTML: Renderable {
+ public func render(indentedBy indentationKind: Indentation.Kind?) -> String {
+ document.render(indentedBy: indentationKind)
+ }
+}
+
+public extension HTML {
+ /// The root context of an HTML document. Plot automatically
+ /// creates all required elements within this context for you.
+ enum RootContext {}
+ /// The user-facing root context of an HTML document. Elements
+ /// like `` and `` are placed within this context.
+ enum DocumentContext: HTMLStylableContext {}
+ /// The context within an HTML document's `` element.
+ enum HeadContext: HTMLContext, HTMLScriptableContext {}
+ /// The context within an HTML document's `` element.
+ class BodyContext: HTMLStylableContext, HTMLScriptableContext {}
+ /// The context within an HTML `` element.
+ final class AbbreviationContext: BodyContext {}
+ /// The context within an HTML `` element.
+ final class AnchorContext: BodyContext, HTMLLinkableContext {}
+ /// The context within an HTML `` element.
+ enum AudioContext: HTMLMediaContext {
+ public typealias SourceContext = AudioSourceContext
+ }
+ /// The context within an audio `` element.
+ enum AudioSourceContext: HTMLSourceContext {}
+ /// The context within an HTML `` element.
+ final class ButtonContext: BodyContext, HTMLNamableContext, HTMLValueContext {}
+ /// The context within an HTML `` element.
+ class DataContext: BodyContext, HTMLValueContext {}
+ /// The context within an HTML `` element.
+ enum DataListContext: HTMLOptionListContext {}
+ /// The context within an HTML `` element.
+ enum DescriptionListContext: HTMLStylableContext {}
+ /// The context within an HTML `` element.
+ final class DetailsContext: BodyContext {}
+ /// The context within an HTML `` element.
+ enum EmbedContext: HTMLStylableContext, HTMLSourceContext, HTMLTypeContext, HTMLDimensionContext {}
+ /// The context within an HTML `
World & Everyone!
]]>",
+ "",
+ ""
+ ]
+
+ assertEqualPodcastFeedContent(feed, expectedComponents.joined())
+ }
+}
+
+extension PodcastFeedTests {
+ static var allTests: Linux.TestList {
+ [
+ ("testEmptyFeed", testEmptyFeed),
+ ("testNewFeedURL", testNewFeedURL),
+ ("testPodcastTitle", testPodcastTitle),
+ ("testPodcastSubtitle", testPodcastSubtitle),
+ ("testPodcastDescription", testPodcastDescription),
+ ("testPodcastSummary", testPodcastSummary),
+ ("testPodcastURL", testPodcastURL),
+ ("testPodcastAtomLink", testPodcastAtomLink),
+ ("testPodcastLanguage", testPodcastLanguage),
+ ("testPodcastTTL", testPodcastTTL),
+ ("testPodcastCopyright", testPodcastCopyright),
+ ("testPodcastAuthor", testPodcastAuthor),
+ ("testPodcastExplicitFlag", testPodcastExplicitFlag),
+ ("testPodcastOwner", testPodcastOwner),
+ ("testPodcastCategory", testPodcastCategory),
+ ("testPodcastSubcategory", testPodcastSubcategory),
+ ("testPodcastType", testPodcastType),
+ ("testPodcastImage", testPodcastImage),
+ ("testPodcastPublicationDate", testPodcastPublicationDate),
+ ("testPodcastLastBuildDate", testPodcastLastBuildDate),
+ ("testEpisodeGUID", testEpisodeGUID),
+ ("testEpisodeTitle", testEpisodeTitle),
+ ("testEpisodeDescription", testEpisodeDescription),
+ ("testEpisodeURL", testEpisodeURL),
+ ("testEpisodePublicationDate", testEpisodePublicationDate),
+ ("testEpisodeDuration", testEpisodeDuration),
+ ("testSeasonNumber", testSeasonNumber),
+ ("testEpisodeNumber", testEpisodeNumber),
+ ("testEpisodeType", testEpisodeType),
+ ("testEpisodeAudio", testEpisodeAudio),
+ ("testEpisodeHTMLContent", testEpisodeHTMLContent)
+ ]
+ }
+}
diff --git a/Tests/PlotTests/RSSTests.swift b/Tests/PlotTests/RSSTests.swift
new file mode 100644
index 0000000..0a643b2
--- /dev/null
+++ b/Tests/PlotTests/RSSTests.swift
@@ -0,0 +1,149 @@
+/**
+* Plot
+* Copyright (c) John Sundell 2019
+* MIT license, see LICENSE file for details
+*/
+
+import XCTest
+import Plot
+
+final class RSSTests: XCTestCase {
+ func testEmptyFeed() {
+ let feed = RSS()
+ assertEqualRSSFeedContent(feed, "")
+ }
+
+ func testFeedTitle() {
+ let feed = RSS(.title("MyPodcast"))
+ assertEqualRSSFeedContent(feed, "MyPodcast ")
+ }
+
+ func testFeedDescription() {
+ let feed = RSS(.description("Description"))
+ assertEqualRSSFeedContent(feed, "Description ")
+ }
+
+ func testFeedURL() {
+ let feed = RSS(.link("url.com"))
+ assertEqualRSSFeedContent(feed, "en-US ")
+ }
+
+ func testFeedTTL() {
+ let feed = RSS(.ttl(200))
+ assertEqualRSSFeedContent(feed, "200 ")
+ }
+
+ func testFeedPublicationDate() throws {
+ let stubs = try Date.makeStubs(withFormattingStyle: .rss)
+ let feed = RSS(.pubDate(stubs.date, timeZone: stubs.timeZone))
+ assertEqualRSSFeedContent(feed, "\(stubs.expectedString) ")
+ }
+
+ func testFeedLastBuildDate() throws {
+ let stubs = try Date.makeStubs(withFormattingStyle: .rss)
+ let feed = RSS(.lastBuildDate(stubs.date, timeZone: stubs.timeZone))
+ assertEqualRSSFeedContent(feed, "\(stubs.expectedString) ")
+ }
+
+ func testItemGUID() {
+ let feed = RSS(
+ .item(.guid("123")),
+ .item(.guid("url.com", .isPermaLink(true))),
+ .item(.guid("123", .isPermaLink(false)))
+ )
+
+ assertEqualRSSFeedContent(feed, """
+ 123 url.com 123 Title Description \(stubs.expectedString) Hello
World & Everyone!
"
+ )))
+
+ assertEqualRSSFeedContent(feed, """
+ - \
+
\
+ HelloWorld & Everyone!
]]>\
+ \
+
+ """)
+ }
+
+ func testItemHTMLDSLContent() {
+ let feed = RSS(.item(
+ .content(.h1("Title"))
+ ))
+
+ assertEqualRSSFeedContent(feed, """
+ - \
+
\
+ Title]]>\
+ \
+
+ """)
+ }
+}
+
+extension RSSTests {
+ static var allTests: Linux.TestList {
+ [
+ ("testEmptyFeed", testEmptyFeed),
+ ("testFeedTitle", testFeedTitle),
+ ("testFeedDescription", testFeedDescription),
+ ("testFeedURL", testFeedURL),
+ ("testFeedAtomLink", testFeedAtomLink),
+ ("testFeedLanguage", testFeedLanguage),
+ ("testFeedTTL", testFeedTTL),
+ ("testFeedPublicationDate", testFeedPublicationDate),
+ ("testFeedLastBuildDate", testFeedLastBuildDate),
+ ("testItemGUID", testItemGUID),
+ ("testItemTitle", testItemTitle),
+ ("testItemDescription", testItemDescription),
+ ("testItemURL", testItemURL),
+ ("testItemPublicationDate", testItemPublicationDate),
+ ("testItemHTMLStringContent", testItemHTMLStringContent),
+ ("testItemHTMLDSLContent", testItemHTMLDSLContent)
+ ]
+ }
+}
diff --git a/Tests/PlotTests/Require.swift b/Tests/PlotTests/Require.swift
new file mode 100644
index 0000000..e61bf06
--- /dev/null
+++ b/Tests/PlotTests/Require.swift
@@ -0,0 +1,26 @@
+/**
+* Plot
+* Copyright (c) John Sundell 2019
+* MIT license, see LICENSE file for details
+*/
+
+import Foundation
+
+func require(_ expression: @autoclosure () -> T?,
+ file: StaticString = #file,
+ line: UInt = #line) throws -> T {
+ guard let value = expression() else {
+ throw RequireError(file: file, line: line)
+ }
+
+ return value
+}
+
+private struct RequireError: LocalizedError {
+ let file: StaticString
+ let line: UInt
+
+ var errorDescription: String? {
+ return "Required value of type \(Value.self) was nil at line \(line) in \(file)."
+ }
+}
diff --git a/Tests/PlotTests/SiteMapTests.swift b/Tests/PlotTests/SiteMapTests.swift
new file mode 100644
index 0000000..d941cd2
--- /dev/null
+++ b/Tests/PlotTests/SiteMapTests.swift
@@ -0,0 +1,65 @@
+/**
+* Plot
+* Copyright (c) John Sundell 2019
+* MIT license, see LICENSE file for details
+*/
+
+import XCTest
+import Plot
+
+final class SiteMapTests: XCTestCase {
+ func testEmptyMap() {
+ let map = SiteMap()
+ assertEqualSiteMapContent(map, "")
+ }
+
+ func testDailyUpdatedLocation() throws {
+ let dateStubs = try Date.makeStubs(withFormattingStyle: .siteMap)
+
+ let map = SiteMap(.url(
+ .loc("url.com"),
+ .changefreq(.daily),
+ .priority(1.0),
+ .lastmod(dateStubs.date, timeZone: dateStubs.timeZone)
+ ))
+
+ assertEqualSiteMapContent(map, """
+ \
+ url.com \
+ daily \
+ 1.0 \
+ \(dateStubs.expectedString) \
+
+ """)
+ }
+
+ func testMonthlyUpdatedLocation() throws {
+ let dateStubs = try Date.makeStubs(withFormattingStyle: .siteMap)
+
+ let map = SiteMap(.url(
+ .loc("url.com"),
+ .changefreq(.monthly),
+ .priority(1.0),
+ .lastmod(dateStubs.date, timeZone: dateStubs.timeZone)
+ ))
+
+ assertEqualSiteMapContent(map, """
+ \
+ url.com \
+ monthly \
+ 1.0 \
+ \(dateStubs.expectedString) \
+
+ """)
+ }
+}
+
+extension SiteMapTests {
+ static var allTests: Linux.TestList {
+ [
+ ("testEmptyMap", testEmptyMap),
+ ("testDailyUpdatedLocation", testDailyUpdatedLocation),
+ ("testMonthlyUpdatedLocation", testMonthlyUpdatedLocation)
+ ]
+ }
+}
diff --git a/Tests/PlotTests/XCTestManifests.swift b/Tests/PlotTests/XCTestManifests.swift
new file mode 100644
index 0000000..8253bfa
--- /dev/null
+++ b/Tests/PlotTests/XCTestManifests.swift
@@ -0,0 +1,20 @@
+/**
+* Plot
+* Copyright (c) John Sundell 2019
+* MIT license, see LICENSE file for details
+*/
+
+import XCTest
+
+public func allTests() -> [Linux.TestCase] {
+ return [
+ Linux.makeTestCase(using: ControlFlowTests.allTests),
+ Linux.makeTestCase(using: DocumentTests.allTests),
+ Linux.makeTestCase(using: HTMLTests.allTests),
+ Linux.makeTestCase(using: NodeTests.allTests),
+ Linux.makeTestCase(using: PodcastFeedTests.allTests),
+ Linux.makeTestCase(using: RSSTests.allTests),
+ Linux.makeTestCase(using: SiteMapTests.allTests),
+ Linux.makeTestCase(using: XMLTests.allTests)
+ ]
+}
diff --git a/Tests/PlotTests/XMLTests.swift b/Tests/PlotTests/XMLTests.swift
new file mode 100644
index 0000000..ff98210
--- /dev/null
+++ b/Tests/PlotTests/XMLTests.swift
@@ -0,0 +1,58 @@
+/**
+* Plot
+* Copyright (c) John Sundell 2019
+* MIT license, see LICENSE file for details
+*/
+
+import XCTest
+import Plot
+
+final class XMLTests: XCTestCase {
+ func testEmptyXML() {
+ assertEqualXMLContent(XML(), "")
+ }
+
+ func testSingleElement() {
+ let xml = XML(.element(named: "hello", text: "world!"))
+ assertEqualXMLContent(xml, "world! ")
+ }
+
+ func testSelfClosingElement() {
+ let xml = XML(.selfClosedElement(named: "element"))
+ assertEqualXMLContent(xml, " {
+ [
+ ("testEmptyXML", testEmptyXML),
+ ("testSingleElement", testSingleElement),
+ ("testSelfClosingElement", testSelfClosingElement),
+ ("testElementWithAttribute", testElementWithAttribute),
+ ("testElementWithChildren", testElementWithChildren)
+ ]
+ }
+}
+
+ 
+ 
+ 
+