Add execution type (#3)

* Add execution type

* Add more test

Author: juandahurt

.swiftpm/Pepe.xctestplan

@@ -0,0 +1,32 @@
+{
+  "configurations" : [
+    {
+      "id" : "6192FF30-10FA-48B4-99EA-8DA67CA00FF5",
+      "name" : "Test Scheme Action",
+      "options" : {
+
+      }
+    }
+  ],
+  "defaultOptions" : {
+    "codeCoverage" : {
+      "targets" : [
+        {
+          "containerPath" : "container:",
+          "identifier" : "Pepe",
+          "name" : "Pepe"
+        }
+      ]
+    }
+  },
+  "testTargets" : [
+    {
+      "target" : {
+        "containerPath" : "container:",
+        "identifier" : "PepeTests",
+        "name" : "PepeTests"
+      }
+    }
+  ],
+  "version" : 1
+}

.swiftpm/xcode/xcshareddata/xcschemes/Pepe.xcscheme

@@ -40,8 +40,13 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      shouldUseLaunchSchemeArgsEnv = "YES"
-      shouldAutocreateTestPlan = "YES">
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <TestPlans>
+         <TestPlanReference
+            reference = "container:.swiftpm/Pepe.xctestplan"
+            default = "YES">
+         </TestPlanReference>
+      </TestPlans>
       <Testables>
          <TestableReference
             skipped = "NO">

Sources/Pepe/Log.swift

@@ -0,0 +1,41 @@
+//
+//  Log.swift
+//  
+//
+//  Created by Juan Hurtado on 16/09/23.
+//
+
+import Foundation
+
+struct Log {
+    /// Message to be logged.
+    var message: String
+    /// How importante the log is.
+    let level: LogLevel
+    /// The time when the message is logged.
+    let date: Date
+    
+    init(message: String, level: LogLevel) {
+        self.message = message
+        self.level = level
+        self.date = Date()
+    }
+}
+
+/// Indicates how important a message is.
+public enum LogLevel {
+    case info, debug, warning, error
+    
+    var description: String {
+        switch self {
+        case .info:
+            return "INFO"
+        case .debug:
+            return "DEBUG"
+        case .warning:
+            return "WARNING"
+        case .error:
+            return "ERROR"
+        }
+    }
+}

Sources/Pepe/LogModifier.swift

@@ -33,11 +33,8 @@ public class LogModifier: Equatable {
 
     /// Modifies a certain massage.
     /// - Parameters:
-    ///   - message: Message to be modified.
-    ///   - level: Log level.
-    func modify(_ message: String, level: LogLevel) -> String {
-        message
-    }
+    ///   - log: Message to be modified.
+    func modify(_ log: inout Log) {}
 
     public static func == (lhs: LogModifier, rhs: LogModifier) -> Bool {
         lhs.id == rhs.id
@@ -46,24 +43,23 @@ public class LogModifier: Equatable {
 
 // MARK: - Hi modifier
 public class PepeModifier: LogModifier {
-    override func modify(_ message: String, level: LogLevel) -> String {
-        "🐸: \(message)"
+    override func modify(_ log: inout Log) {
+        log.message = "🐸: \(log.message)"
     }
 }
 
 // MARK: - Level modifier
 public class LevelModifier: LogModifier {
-    override func modify(_ message: String, level: LogLevel) -> String {
-        "[\(level.description)] \(message)"
+    override func modify(_ log: inout Log) {
+        log.message = "[\(log.level.description)] \(log.message)"
     }
 }
 
 // MARK: - Time modifier
 public class TimeModifier: LogModifier {
-    override func modify(_ message: String, level: LogLevel) -> String {
-        let now = Date()
+    override func modify(_ log: inout Log) {
         let formatter = DateFormatter()
         formatter.dateFormat = "HH:mm:ss.SSSS"
-        return formatter.string(from: now).appending(" \(message)")
+        log.message = formatter.string(from: log.date).appending(" \(log.message)")
     }
 }

Sources/Pepe/PepeLogger.swift

@@ -12,48 +12,49 @@ import os
 public struct PepeLogger {
     /// A set of modifiers to be apllied to every log message.
     /// Notice that, is you set an empty array, the logged string will be the one that you provide.
-    var modifiers: [LogModifier]
+    public var modifiers: [LogModifier]
 
     /// Indicates how the message will be logged or "written". By default, the messages will be logged
     /// on the console.
-    var writer: Writer
+    public var writer: Writer
+    
+    /// How the log operation will be executed.
+    public var executionType: ExecutionType
+    
+    /// Internal property to allow syncronous execution.
+    private let _lock = NSRecursiveLock()
+    
+    public enum ExecutionType: Equatable {
+        case async(DispatchQueue), sync
+    }
 
     init() {
         modifiers = [.pepe]
         writer = .console
+        executionType = .sync
     }
 
     /// Logs a message using the previously specified writer.
     /// - Parameters:
     ///   - message: Message to be logged.
     ///   - level: Inidicates how important this message is.
     public func log(_ message: String, level: LogLevel = .info) {
-        _log(message, level: level)
+        switch executionType {
+        case .async(let dispatchQueue):
+            dispatchQueue.async {
+                _log(message, level: level)
+            }
+        case .sync:
+            _lock.lock(); defer { _lock.unlock() }
+            _log(message, level: level)
+        }
     }
 
     private func _log(_ message: String, level: LogLevel) {
-        var message = message
+        var log = Log(message: message, level: level)
         modifiers.reversed().forEach {
-            message = $0.modify(message, level: level)
-        }
-        writer.write(message: message)
-    }
-}
-
-/// Indicates how important a message is.
-public enum LogLevel {
-    case info, debug, warning, error
-    
-    var description: String {
-        switch self {
-        case .info:
-            return "INFO"
-        case .debug:
-            return "DEBUG"
-        case .warning:
-            return "WARNING"
-        case .error:
-            return "ERROR"
+            $0.modify(&log)
         }
+        writer.write(message: log.message)
     }
 }

Tests/PepeTests/PepeLoggerTests.swift

@@ -9,9 +9,22 @@ import XCTest
 @testable import Pepe
 
 final class PepeLoggerTests: XCTestCase {
-    func test_initialState_shouldBeDefaultOne() {
+    func testState_whenInit_shouldBeDefaultOne() {
         let logger = Pepe.loggerPlease()
         XCTAssertEqual(logger.modifiers, [.pepe])
         XCTAssertEqual(logger.writer, .console)
+        XCTAssertEqual(logger.executionType, .sync)
+    }
+    
+    func testLogging_withHeavyConfig_shouldExecuteWithReasonableTime() {
+        let reasonableTime = 0.5
+        var logger = Pepe.loggerPlease()
+        logger.modifiers = [.pepe, .level, .time]
+        logger.writer = .os(subsystem: "pepe", category: "perf_test")
+        let start = Date()
+        logger.log("message")
+        let end = Date()
+        let interval = end.timeIntervalSinceReferenceDate - start.timeIntervalSinceReferenceDate
+        XCTAssertTrue(interval < reasonableTime)
     }
 }