Replace _functionBuilder with resultBuilder

gonzalezreal · Feb 10, 2021 · 4baef88 · 4baef88
1 parent f3e29fb
commit 4baef88
Show file tree

Hide file tree

Showing 9 changed files with 396 additions and 54 deletions.
diff --git a/Package.swift b/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:5.4
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription

diff --git a/Sources/CommonMark/Builders/BlockBuilder.swift b/Sources/CommonMark/Builders/BlockBuilder.swift
@@ -1,13 +1,17 @@
 import Foundation
 
-@_functionBuilder
+@resultBuilder
 public enum BlockBuilder {
     public static func buildBlock(_ values: BlockConvertible...) -> [Block] {
         values.flatMap { $0.asBlocks() }
     }
 
-    public static func buildIf(_ value: BlockConvertible?) -> BlockConvertible {
-        value ?? []
+    public static func buildArray(_ components: [BlockConvertible]) -> [Block] {
+        components.flatMap { $0.asBlocks() }
+    }
+
+    public static func buildOptional(_ component: BlockConvertible?) -> BlockConvertible {
+        component ?? []
     }
 
     public static func buildEither(first: BlockConvertible) -> BlockConvertible {

diff --git a/Sources/CommonMark/Builders/ForEach.swift b/Sources/CommonMark/Builders/ForEach.swift
diff --git a/Sources/CommonMark/Builders/InlineBuilder.swift b/Sources/CommonMark/Builders/InlineBuilder.swift
@@ -1,13 +1,17 @@
 import Foundation
 
-@_functionBuilder
+@resultBuilder
 public enum InlineBuilder {
     public static func buildBlock(_ values: InlineConvertible...) -> [Inline] {
         values.flatMap { $0.asInlines() }
     }
 
-    public static func buildIf(_ value: InlineConvertible?) -> InlineConvertible {
-        value ?? []
+    public static func buildArray(_ components: [InlineConvertible]) -> [Inline] {
+        components.flatMap { $0.asInlines() }
+    }
+
+    public static func buildOptional(_ component: InlineConvertible?) -> InlineConvertible {
+        component ?? []
     }
 
     public static func buildEither(first: InlineConvertible) -> InlineConvertible {

diff --git a/Sources/CommonMark/Builders/ItemBuilder.swift b/Sources/CommonMark/Builders/ItemBuilder.swift
@@ -1,12 +1,16 @@
 import Foundation
 
-@_functionBuilder
+@resultBuilder
 public enum ItemBuilder {
     public static func buildBlock(_ values: ItemConvertible...) -> [Item] {
         values.flatMap { $0.asItems() }
     }
 
-    public static func buildIf(_ value: ItemConvertible?) -> ItemConvertible {
+    public static func buildArray(_ components: [ItemConvertible]) -> [Item] {
+        components.flatMap { $0.asItems() }
+    }
+
+    public static func buildOptional(_ value: ItemConvertible?) -> ItemConvertible {
         value ?? []
     }
 

diff --git a/Sources/CommonMark/Core/Item.swift b/Sources/CommonMark/Core/Item.swift
@@ -1,10 +1,3 @@
-//
-//  File.swift
-//
-//
-//  Created by Guille on 6/2/21.
-//
-
 import cmark
 import Foundation
 

diff --git a/Tests/CommonMarkTests/BlockBuilderTests.swift b/Tests/CommonMarkTests/BlockBuilderTests.swift
@@ -0,0 +1,107 @@
+import CommonMark
+import XCTest
+
+final class BlockBuilderTests: XCTestCase {
+    func testBuildBlock() {
+        // given
+        @BlockBuilder func build() -> [Block] {
+            "Hello"
+            "world!"
+        }
+
+        // when
+        let result = build()
+
+        // then
+        XCTAssertEqual(
+            [
+                .paragraph([.text("Hello")]),
+                .paragraph([.text("world!")]),
+            ],
+            result
+        )
+    }
+
+    func testBuildArray() {
+        // given
+        @BlockBuilder func build() -> [Block] {
+            for i in 0 ... 3 {
+                "\(i)"
+            }
+        }
+
+        // when
+        let result = build()
+
+        // then
+        XCTAssertEqual(
+            [
+                .paragraph([.text("0")]),
+                .paragraph([.text("1")]),
+                .paragraph([.text("2")]),
+                .paragraph([.text("3")]),
+            ],
+            result
+        )
+    }
+
+    func testBuildOptional() {
+        @BlockBuilder func build() -> [Block] {
+            "Something is:"
+            if true {
+                BlockQuote {
+                    "true"
+                }
+            }
+        }
+
+        // when
+        let result = build()
+
+        // then
+        XCTAssertEqual(
+            [
+                .paragraph([.text("Something is:")]),
+                .blockQuote(
+                    [.paragraph([.text("true")])]
+                ),
+            ],
+            result
+        )
+    }
+
+    func testBuildEither() {
+        @BlockBuilder func build(_ value: Bool) -> [Block] {
+            "Something is:"
+            if value {
+                BlockQuote {
+                    "true"
+                }
+            } else {
+                "false"
+            }
+        }
+
+        // when
+        let result1 = build(true)
+        let result2 = build(false)
+
+        // then
+        XCTAssertEqual(
+            [
+                .paragraph([.text("Something is:")]),
+                .blockQuote(
+                    [.paragraph([.text("true")])]
+                ),
+            ],
+            result1
+        )
+        XCTAssertEqual(
+            [
+                .paragraph([.text("Something is:")]),
+                .paragraph([.text("false")]),
+            ],
+            result2
+        )
+    }
+}
diff --git a/Tests/CommonMarkTests/InlineBuilderTests.swift b/Tests/CommonMarkTests/InlineBuilderTests.swift
@@ -0,0 +1,109 @@
+import CommonMark
+import XCTest
+
+final class InlineBuilderTests: XCTestCase {
+    func testBuildBlock() {
+        // given
+        @InlineBuilder func build() -> [Inline] {
+            "Hello "
+            Strong { "world!" }
+        }
+
+        // when
+        let result = build()
+
+        // then
+        XCTAssertEqual(
+            [
+                .text("Hello "),
+                .strong(
+                    [.text("world!")]
+                ),
+            ],
+            result
+        )
+    }
+
+    func testBuildArray() {
+        // given
+        @InlineBuilder func build() -> [Inline] {
+            for i in 0 ... 3 {
+                "\(i) "
+            }
+        }
+
+        // when
+        let result = build()
+
+        // then
+        XCTAssertEqual(
+            [
+                .text("0 "),
+                .text("1 "),
+                .text("2 "),
+                .text("3 "),
+            ],
+            result
+        )
+    }
+
+    func testBuildOptional() {
+        @InlineBuilder func build() -> [Inline] {
+            "Something is "
+            if true {
+                Emphasis {
+                    "true"
+                }
+            }
+        }
+
+        // when
+        let result = build()
+
+        // then
+        XCTAssertEqual(
+            [
+                .text("Something is "),
+                .emphasis(
+                    [.text("true")]
+                ),
+            ],
+            result
+        )
+    }
+
+    func testBuildEither() {
+        @InlineBuilder func build(_ value: Bool) -> [Inline] {
+            "Something is "
+            if value {
+                Emphasis {
+                    "true"
+                }
+            } else {
+                "false"
+            }
+        }
+
+        // when
+        let result1 = build(true)
+        let result2 = build(false)
+
+        // then
+        XCTAssertEqual(
+            [
+                .text("Something is "),
+                .emphasis(
+                    [.text("true")]
+                ),
+            ],
+            result1
+        )
+        XCTAssertEqual(
+            [
+                .text("Something is "),
+                .text("false"),
+            ],
+            result2
+        )
+    }
+}