Refactor Parser to return CaptureGroup

Author: cpisciotta

Sources/XcbeautifyLib/CaptureGroups.swift

@@ -1,12 +1,14 @@
 import Foundation
 
-protocol CaptureGroup {
+package protocol CaptureGroup {
     static var outputType: OutputType { get }
     static var regex: XcbeautifyLib.Regex { get }
     init?(groups: [String])
 }
 
 extension CaptureGroup {
+    var outputType: OutputType { Self.outputType }
+
     static var pattern: String { regex.pattern }
     var pattern: String { Self.regex.pattern }
 }

Sources/XcbeautifyLib/Formatter.swift

@@ -1,16 +1,14 @@
 import Foundation
 
-class Formatter {
+package class Formatter {
 
     private let colored: Bool
     private let renderer: OutputRendering
     private let additionalLines: () -> String?
-    private(set) var preserveUnbeautifiedLines = false
 
-    init(
+    package init(
         colored: Bool = true,
         renderer: Renderer,
-        preserveUnbeautifiedLines: Bool = false,
         additionalLines: @escaping () -> (String?)
     ) {
         self.colored = colored
@@ -22,11 +20,10 @@ class Formatter {
             self.renderer = GitHubActionsRenderer()
         }
 
-        self.preserveUnbeautifiedLines = preserveUnbeautifiedLines
         self.additionalLines = additionalLines
     }
 
-    func format(captureGroup: CaptureGroup) -> String? {
+    package func format(captureGroup: CaptureGroup) -> String? {
         return renderer.beautify(
             group: captureGroup,
             additionalLines: additionalLines

Sources/XcbeautifyLib/Parser.swift

@@ -1,8 +1,6 @@
 import Foundation
 
 package class Parser {
-    private let formatter: XcbeautifyLib.Formatter
-
     package private(set) var outputType = OutputType.undefined
 
     private lazy var captureGroupTypes: [CaptureGroup.Type] = [
@@ -94,28 +92,16 @@ package class Parser {
 
     // MARK: - Init
 
-    package init(
-        colored: Bool = true,
-        renderer: Renderer,
-        preserveUnbeautifiedLines: Bool = false,
-        additionalLines: @escaping () -> (String?)
-    ) {
-        self.formatter = Formatter(
-            colored: colored,
-            renderer: renderer,
-            preserveUnbeautifiedLines: preserveUnbeautifiedLines,
-            additionalLines: additionalLines
-        )
-    }
+    public init() { }
 
-    package func parse(line: String) -> String? {
+    public func parse(line: String) -> CaptureGroup? {
         // Find first parser that can parse specified string
         guard let idx = captureGroupTypes.firstIndex(where: { $0.regex.match(string: line) }) else {
             // Some uncommon cases, which have additional logic and don't follow default flow
 
             // Nothing found?
             outputType = OutputType.undefined
-            return formatter.preserveUnbeautifiedLines ? line : nil
+            return nil
         }
 
         guard let captureGroupType = captureGroupTypes[safe: idx] else {
@@ -134,7 +120,7 @@ package class Parser {
         // Move found parser to the top, so next time it will be checked first
         captureGroupTypes.insert(captureGroupTypes.remove(at: idx), at: 0)
 
-        return formatter.format(captureGroup: captureGroup)
+        return captureGroup
     }
 }
 

Sources/XcbeautifyLib/Regex.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-class Regex {
+public final class Regex {
     let pattern: String
 
     private lazy var regex: NSRegularExpression? = try? NSRegularExpression(pattern: "^" + pattern, options: [.caseInsensitive])

Sources/XcbeautifyLib/XCBeautifier.swift

@@ -2,22 +2,35 @@ import Foundation
 
 public struct XCBeautifier {
     private let parser: Parser
+    private let formatter: Formatter
+    private let preserveUnbeautifiedLines: Bool
 
     public init(
         colored: Bool,
         renderer: Renderer,
         preserveUnbeautifiedLines: Bool,
         additionalLines: @escaping () -> String?
     ) {
-        parser = Parser(
+        parser = Parser()
+
+        formatter = Formatter(
             colored: colored,
             renderer: renderer,
-            preserveUnbeautifiedLines: preserveUnbeautifiedLines,
             additionalLines: additionalLines
         )
+
+        self.preserveUnbeautifiedLines = preserveUnbeautifiedLines
     }
 
     public func format(line: String) -> String? {
-        parser.parse(line: line)
+        guard let captureGroup = parser.parse(line: line) else {
+            if preserveUnbeautifiedLines {
+                return line
+            } else {
+                return nil
+            }
+        }
+
+        return formatter.format(captureGroup: captureGroup)
     }
 }

Sources/xcbeautify/Xcbeautify.swift

@@ -49,15 +49,23 @@ struct Xcbeautify: ParsableCommand {
             return line
         }
 
-        let parser = Parser(
+        let parser = Parser()
+
+        let formatter = XcbeautifyLib.Formatter(
             colored: !disableColoredOutput,
             renderer: renderer,
-            preserveUnbeautifiedLines: preserveUnbeautified,
             additionalLines: { readLine() }
         )
 
         while let line = readLine() {
-            guard let formatted = parser.parse(line: line) else { continue }
+            guard let captureGroup = parser.parse(line: line) else {
+                if preserveUnbeautified {
+                    output.write(.undefined, line)
+                }
+
+                continue
+            }
+            guard let formatted = formatter.format(captureGroup: captureGroup) else { continue }
             output.write(parser.outputType, formatted)
         }
 

Tests/XcbeautifyLibTests/ParsingTests/ParsingTests.swift

@@ -8,18 +8,7 @@ final class ParsingTests: XCTestCase {
         var buildLog: [String] = try String(contentsOf: url)
             .components(separatedBy: .newlines)
 
-        let parser = Parser(
-            colored: false,
-            renderer: .terminal,
-            preserveUnbeautifiedLines: false,
-            additionalLines: {
-                guard !buildLog.isEmpty else {
-                    XCTFail("The build log should never be empty when fetching additional lines.")
-                    return nil
-                }
-                return buildLog.removeFirst()
-            }
-        )
+        let parser = Parser()
 
         var uncapturedOutput = 0
 
@@ -36,6 +25,6 @@ final class ParsingTests: XCTestCase {
         // It uses `XCTAssertEqual` instead of `XCTAssertLessThanOrEqual` as a reminder.
         // Update this magic number whenever `uncapturedOutput` is less than the current magic number.
         // There's a regression whenever `uncapturedOutput` is greater than the current magic number.
-        XCTAssertEqual(uncapturedOutput, 2218)
+        XCTAssertEqual(uncapturedOutput, 833)
     }
 }

Tests/XcbeautifyLibTests/RendererTests/GitHubActionsRendererTests.swift

@@ -3,14 +3,17 @@ import XCTest
 
 final class GitHubActionsRendererTests: XCTestCase {
     var parser: Parser!
+    var formatter: XcbeautifyLib.Formatter!
 
     override func setUpWithError() throws {
         try super.setUpWithError()
-        parser = Parser(colored: false, renderer: .gitHubActions, additionalLines: { nil })
+        parser = Parser()
+        formatter = Formatter(colored: false, renderer: .gitHubActions, additionalLines: { nil })
     }
 
     private func logFormatted(_ string: String) -> String? {
-        parser.parse(line: string)
+        guard let captureGroup = parser.parse(line: string) else { return nil }
+        return formatter.format(captureGroup: captureGroup)
     }
 
     func testAggregateTarget() {

Tests/XcbeautifyLibTests/RendererTests/TerminalRendererTests.swift

@@ -3,14 +3,17 @@ import XCTest
 
 final class TerminalRendererTests: XCTestCase {
     var parser: Parser!
+    var formatter: XcbeautifyLib.Formatter!
 
     override func setUpWithError() throws {
         try super.setUpWithError()
-        parser = Parser(colored: false, renderer: .terminal, additionalLines: { nil })
+        parser = Parser()
+        formatter = Formatter(colored: false, renderer: .terminal, additionalLines: { nil })
     }
 
     private func noColoredFormatted(_ string: String) -> String? {
-        parser.parse(line: string)
+        guard let captureGroup = parser.parse(line: string) else { return nil }
+        return formatter.format(captureGroup: captureGroup)
     }
 
     func testAggregateTarget() {