Merge branch 'feat/frizlab/swift_5.1' into develop

Author: Frizlab

Package.resolved

@@ -1,31 +1,21 @@
-// swift-tools-version:5.8
+// swift-tools-version:5.1
 import PackageDescription
 
 
-let swiftSettings: [SwiftSetting] = [
-	.enableExperimentalFeature("StrictConcurrency")
-]
-
 let package = Package(
 	name: "json-logger",
-	platforms: [
-		.macOS(.v11),
-		.tvOS(.v14),
-		.iOS(.v14),
-		.watchOS(.v7),
-	],
 	products: [
 		.library(name: "JSONLogger", targets: ["JSONLogger"])
 	],
 	dependencies: [
 		.package(url: "https://github.com/apple/swift-log.git",      from: "1.5.1"),
-		.package(url: "https://github.com/Frizlab/generic-json.git", from: "3.0.0"),
+		.package(url: "https://github.com/Frizlab/generic-json.git", from: "3.1.3"),
 	],
 	targets: [
 		.target(name: "JSONLogger", dependencies: [
 			.product(name: "GenericJSON",   package: "generic-json"),
 			.product(name: "Logging",       package: "swift-log"),
-		], path: "Sources", swiftSettings: swiftSettings),
-		.testTarget(name: "JSONLoggerTests", dependencies: ["JSONLogger"], path: "Tests", swiftSettings: swiftSettings)
+		], path: "Sources"),
+		.testTarget(name: "JSONLoggerTests", dependencies: ["JSONLogger"]),
 	]
 )

Package.swift

@@ -0,0 +1,30 @@
+// swift-tools-version:5.8
+import PackageDescription
+
+
+//let swiftSettings: [SwiftSetting] = []
+let swiftSettings: [SwiftSetting] = [.enableExperimentalFeature("StrictConcurrency")]
+
+let package = Package(
+	name: "json-logger",
+	platforms: [
+		.macOS(.v11),
+		.tvOS(.v14),
+		.iOS(.v14),
+		.watchOS(.v7),
+	],
+	products: [
+		.library(name: "JSONLogger", targets: ["JSONLogger"])
+	],
+	dependencies: [
+		.package(url: "https://github.com/apple/swift-log.git",      from: "1.5.1"),
+		.package(url: "https://github.com/Frizlab/generic-json.git", from: "3.1.3"),
+	],
+	targets: [
+		.target(name: "JSONLogger", dependencies: [
+			.product(name: "GenericJSON",   package: "generic-json"),
+			.product(name: "Logging",       package: "swift-log"),
+		], path: "Sources", swiftSettings: swiftSettings),
+		.testTarget(name: "JSONLoggerTests", dependencies: ["JSONLogger"], swiftSettings: swiftSettings),
+	]
+)

[email protected]

@@ -0,0 +1,8 @@
+import Foundation
+
+
+#if swift(>=5.5)
+public protocol JSONLogger_Sendable : Sendable {}
+#else
+public protocol JSONLogger_Sendable {}
+#endif

Sources/DummySendable.swift

@@ -39,14 +39,17 @@ public struct JSONLogger : LogHandler {
 
 	public static let defaultJSONEncoder: JSONEncoder = {
 		let res = JSONEncoder()
+#if swift(>=5.3)
 		res.outputFormatting = [.withoutEscapingSlashes]
+#endif
 		res.keyEncodingStrategy = .useDefaultKeys
 		res.dateEncodingStrategy = .iso8601
 		res.dataEncodingStrategy = .base64
 		res.nonConformingFloatEncodingStrategy = .convertToString(positiveInfinity: "+inf", negativeInfinity: "-inf", nan: "nan")
 		return res
 	}()
 
+#if swift(>=5.7)
 	public static let defaultJSONCodersForStringConvertibles: (JSONEncoder, JSONDecoder) = {
 		let encoder = JSONEncoder()
 		encoder.outputFormatting = [.withoutEscapingSlashes]
@@ -72,6 +75,7 @@ public struct JSONLogger : LogHandler {
 		decoder.nonConformingFloatDecodingStrategy = .throw
 		return (encoder, decoder)
 	}()
+#endif
 
 	public var logLevel: Logger.Level = .info
 
@@ -88,11 +92,14 @@ public struct JSONLogger : LogHandler {
 	public let suffix: Data
 
 	public let jsonEncoder: JSONEncoder
+#if swift(>=5.7)
 	/**
 	 If non-`nil`, the `Encodable` stringConvertible properties in the metadata will be encoded as `JSON` using the `JSONEncoder` and `JSONDecoder`.
 	 If the encoding fails or this property is set to `nil` the String value will be used. */
 	public let jsonCodersForStringConvertibles: (JSONEncoder, JSONDecoder)?
+#endif
 
+#if swift(>=5.7)
 	public static func forJSONSeq(
 		on fh: FileHandle = .standardOutput,
 		label: String,
@@ -129,6 +136,41 @@ public struct JSONLogger : LogHandler {
 		self.metadataProvider = metadataProvider
 	}
 
+#else
+	
+	public static func forJSONSeq(
+		on fh: FileHandle = .standardOutput,
+		label: String,
+		jsonEncoder: JSONEncoder = Self.defaultJSONEncoder,
+		metadataProvider: Logger.MetadataProvider? = LoggingSystem.metadataProvider
+	) -> Self {
+		return Self(
+			label: label,
+			fileHandle: fh,
+			lineSeparator: Data(), prefix: Data([0x1e]), suffix: Data([0x0a]),
+			jsonEncoder: jsonEncoder,
+			metadataProvider: metadataProvider
+		)
+	}
+	
+	public init(
+		label: String,
+		fileHandle: FileHandle = .standardOutput,
+		lineSeparator: Data = Data(), prefix: Data = Data(), suffix: Data = Data("\n".utf8),
+		jsonEncoder: JSONEncoder = Self.defaultJSONEncoder,
+		metadataProvider: Logger.MetadataProvider? = LoggingSystem.metadataProvider
+	) {
+		self.label = label
+		self.outputFileHandle = fileHandle
+		self.lineSeparator = lineSeparator
+		self.prefix = prefix
+		self.suffix = suffix
+		self.jsonEncoder = jsonEncoder
+		
+		self.metadataProvider = metadataProvider
+	}
+#endif
+	
 	public subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
 		get {metadata[metadataKey]}
 		set {metadata[metadataKey] = newValue}
@@ -206,7 +248,7 @@ extension JSONLogger {
 	 Merge the logger’s metadata, the provider’s metadata and the given explicit metadata and return the new metadata.
 	 If the provider’s metadata and the explicit metadata are `nil`, returns `nil` to signify the current `jsonMetadataCache` can be used. */
 	private func mergedMetadata(with explicit: Logger.Metadata?) -> Logger.Metadata? {
-		var metadata = metadata
+		var metadata = self.metadata
 		let provided = metadataProvider?.get() ?? [:]
 
 		guard !provided.isEmpty || !((explicit ?? [:]).isEmpty) else {
@@ -233,6 +275,8 @@ extension JSONLogger {
 			case let .array(array):           return .array (array     .map      (jsonMetadataValue(_:)))
 			case let .dictionary(dictionary): return .object(dictionary.mapValues(jsonMetadataValue(_:)))
 			case let .stringConvertible(s):
+				/* Swift 5.7 and more. */
+#if swift(>=5.7)
 				if let (encoder, decoder) = jsonCodersForStringConvertibles,
 					let c = s as? any Encodable,
 					let data = try? encoder.encode(c),
@@ -242,6 +286,9 @@ extension JSONLogger {
 				} else {
 					return .string(s.description)
 				}
+#else
+				return .string(s.description)
+#endif
 		}
 
 	}

Sources/JSONLogger.swift

@@ -5,7 +5,11 @@ import Logging
 
 
 
-public struct LogLine : Hashable, Codable, Sendable {
+/* Technically Sendable is available starting at Swift 5.5, but swift-log was not ready at the time so we have to use Swift 5.6 instead. */
+#if swift(>=5.6)
+extension LogLine : JSONLogger_Sendable {}
+#endif
+public struct LogLine : Hashable, Codable {
 
 	public var level: Logger.Level
 	public var message: String

Sources/LogLine.swift

@@ -5,13 +5,14 @@ import Foundation
 internal extension String {
 
 	func safifyForJSON() -> String {
-		let ascii = unicodeScalars.lazy.map{ scalar in
+		let ascii = unicodeScalars.lazy.map{ scalar -> String in
+			/* Note: The #""# syntax is available starting at Swift 5.4. */
 			switch scalar {
 				case _ where !scalar.isASCII: return "-"
-				case #"\"#: return #"\\"#
-				case #"""#: return #"\""#
-				case "\n": return #"\n"#
-				case "\r": return #"\r"#
+				case "\\": return "\\\\"
+				case "\"": return "\\\""
+				case "\n": return "\\n"
+				case "\r": return "\\r"
 				/* `scalar.value` should never be bigger than Int32.max, but we still use bitPattern not to crash if it is. */
 				case _ where isprint(Int32(bitPattern: scalar.value)) == 0: return "-"
 				default: return String(scalar)

Sources/String+Utils.swift

@@ -69,6 +69,7 @@ final class JSONLoggerTests : XCTestCase {
 		XCTAssertEqual(data.first, 0x0a)
 	}
 
+#if swift(>=5.7)
 	func testEncodeMetadataAsJSON() throws {
 		struct BestStruct : Encodable, CustomStringConvertible {
 			var val: Int
@@ -81,12 +82,13 @@ final class JSONLoggerTests : XCTestCase {
 		jsonLogger.log(level: ref.level, message: "\(ref.message)", metadata: ["yolo": .stringConvertible(BestStruct(val: 21))], source: ref.source, file: ref.file, function: ref.function, line: ref.line)
 		try pipe.fileHandleForWriting.close()
 		let data = try pipe.fileHandleForReading.readToEnd() ?? Data()
-		print(data.reduce("", { $0 + String(format: "%02x", $1) }))
+		//print(data.reduce("", { $0 + String(format: "%02x", $1) }))
 		var line = try Self.defaultJSONDecoder.decode(LogLine.self, from: data)
 		XCTAssertLessThanOrEqual(line.date.timeIntervalSince(ref.date), 0.1)
 		line.date = ref.date
 		XCTAssertEqual(line, ref)
 	}
+#endif
 
 	func testFallbackOnLogLineEncodeFailure() throws {
 		struct BestStruct : Encodable, CustomStringConvertible {
@@ -100,7 +102,7 @@ final class JSONLoggerTests : XCTestCase {
 		]), date: Date(), label: "best-logger", source: "dummy-source", file: "dummy-file", function: "dummy-function", line: 42)
 
 		struct AnError : Error {}
-		let failEncoder = {
+		let failEncoder = { () -> JSONEncoder in
 			let res = JSONEncoder()
 			res.dateEncodingStrategy = .custom({ _, _ in throw AnError() })
 			return res

Tests/JSONLoggerTests.swift renamed to Tests/JSONLoggerTests/JSONLoggerTests.swift

@@ -0,0 +1,50 @@
+import Foundation
+import XCTest
+
+@testable import JSONLoggerTests
+
+
+
+let tests_swift57_JSONLoggerTests: [(String, (JSONLoggerTests) -> () throws -> Void)]
+#if swift(>=5.7)
+tests_swift57_JSONLoggerTests = [
+	("testEncodeMetadataAsJSON", JSONLoggerTests.testEncodeMetadataAsJSON),
+]
+#else
+tests_swift57_JSONLoggerTests = []
+#endif
+var tests: [XCTestCaseEntry] = [
+	testCase([
+		("test0NoSeparatorForFirstLog", JSONLoggerTests.test0NoSeparatorForFirstLog),
+		("testFromDoc", JSONLoggerTests.testFromDoc),
+		("testSeparatorForNotFirstLog", JSONLoggerTests.testSeparatorForNotFirstLog),
+		("testFallbackOnLogLineEncodeFailure", JSONLoggerTests.testFallbackOnLogLineEncodeFailure),
+		("testDecodeLogLineWithBothValidDateAndMangledDate", JSONLoggerTests.testDecodeLogLineWithBothValidDateAndMangledDate),
+		("testDecodeLogLineWithBothInvalidDateAndMangledDate", JSONLoggerTests.testDecodeLogLineWithBothInvalidDateAndMangledDate),
+	] + tests_swift57_JSONLoggerTests),
+]
+#if !os(WASI)
+XCTMain(tests)
+
+#else
+/* Compilation fails for Swift <5.5… */
+//await XCTMain(tests)
+
+/* Let’s print a message to inform the tests on WASI are disabled. */
+let brightRed = "\u{1B}[91;1m"
+let gray = "\u{1B}[38;5;245m"
+let magenta = "\u{1B}[35;1m"
+let reset = "\u{1B}[0m"
+try FileHandle.standardError.write(contentsOf: Data("""
+\(brightRed)Tests are disabled on WASI\(reset):
+\(gray)This package is compatible with Swift <5.4, so we have to add a LinuxMain file in which we call XCTMain.
+On WASI the XCTMain function is async, so we have to #if the XCTMain call, one with the await keyword, the other without.
+However, on Swift <5.5 the LinuxMain setup like this does not compile because the old compiler does not know the await keyword
+ (even though the whole code is ignored because we do not compile for WASI whe compiling with an old compiler).
+I also tried doing a #if swift(>=5.5) check, but that do not work either.\(reset)
+
+\(magenta)To temporarily enable the tests for WASI, uncomment the `await XCTMain(tests)` line in LinuxMain.swift.\(reset)
+
+""".utf8))
+
+#endif