Merge branch 'fix/frizlab/no_platforms_in_package' into develop

Author: Frizlab

Package.swift

@@ -4,12 +4,6 @@ import PackageDescription
 
 let package = Package(
 	name: "clt-logger",
-	platforms: [
-		.macOS(.v10_15),
-		.tvOS(.v13),
-		.iOS(.v13),
-		.watchOS(.v6),
-	],
 	products: [
 		.library(name: "CLTLogger", targets: ["CLTLogger"]),
 	],

[email protected]

@@ -7,12 +7,6 @@ let swiftSettings: [SwiftSetting] = [.enableExperimentalFeature("StrictConcurren
 
 let package = Package(
 	name: "clt-logger",
-	platforms: [
-		.macOS(.v11),
-		.tvOS(.v14),
-		.iOS(.v14),
-		.watchOS(.v7),
-	],
 	products: [
 		.library(name: "CLTLogger", targets: ["CLTLogger"]),
 	],

Sources/NSLock+withLock.swift

@@ -1,4 +1,4 @@
-#if (os(Linux) && swift(<6.0)) || swift(<5.7)
+#if (!canImport(Darwin) && swift(<6.0)) || swift(<5.7)
 import Foundation
 
 

Sources/SGR.swift

@@ -15,9 +15,9 @@ import Foundation
  - [The 8-bits colors table (direct image link)](<https://i.stack.imgur.com/KTSQa.png>);
  - [List of Terminals supporting True Colors](<https://gist.github.com/XVilka/8346728>);
  - [The ODA Specs](<https://en.wikipedia.org/wiki/Open_Document_Architecture#External_links>) aka. CCITT T.411-T.424 (equivalent to ISO 8613, but freely downloadable). */
-public struct SGR : RawRepresentable, Hashable, CustomStringConvertible {
+public struct SGR : RawRepresentable, Hashable, CustomStringConvertible, CLTLogger_Sendable {
 
-	public enum Modifier : RawRepresentable, Hashable, CustomStringConvertible {
+	public enum Modifier : RawRepresentable, Hashable, CustomStringConvertible, CLTLogger_Sendable {
 
 		/** Reset/Normal -- All attributes off. */
 		case reset
@@ -303,7 +303,7 @@ public struct SGR : RawRepresentable, Hashable, CustomStringConvertible {
 		 Not standard (equivalent to `.bgColorTo4BitWhite` + `.bold` + `.reverseVideo` IIUC). */
 		case bgColorTo4BitBrightWhite
 
-		public struct ColorSpaceInfo {
+		public struct ColorSpaceInfo : Hashable, CLTLogger_Sendable {
 
 			/**
 			 - Note: I did not know the type for this one, so I assumed `Int`. */
@@ -315,7 +315,7 @@ public struct SGR : RawRepresentable, Hashable, CustomStringConvertible {
 			public var colorSpaceToleranceAsString: String? {colorSpaceTolerance.flatMap{ "\($0)" }}
 			public var colorSpaceAssociatedWithToleranceAsString: String? {colorSpaceAssociatedWithTolerance.flatMap{ "\($0.rawValue)" }}
 
-			public enum ColorSpaceForTolerance : Int {
+			public enum ColorSpaceForTolerance : Int, Hashable, CLTLogger_Sendable {
 				case cieluv = 0
 				case cielab = 1
 			}
@@ -454,19 +454,19 @@ public struct SGR : RawRepresentable, Hashable, CustomStringConvertible {
 		/* Note: This init probably has terrible perfs. */
 		init?(scanner: Scanner) {
 			struct DummyError : Error {}
-			let originalScannerIndex = scanner.currentIndex
+			let originalScanLocation = scanner.compatibleScanLocation
 			do {
 				enum ColorDestination : String {
 					case fg = "38"
 					case bg = "48"
 					case ul = "58"
 				}
-				let token = scanner.scanUpToCharacters(from: CharacterSet(charactersIn: String(Self.separatorChar) + String(SGR.sgrEndChar))) ?? ""
+				let token = scanner.xl_scanUpToCharacters(from: CharacterSet(charactersIn: String(Self.separatorChar) + String(SGR.sgrEndChar))) ?? ""
 				if token.contains(":") {
 					/* Let’s process the special ODA cases. */
 					let subScanner = Scanner(forParsing: token)
-					let subToken = subScanner.scanUpToString(":") ?? ""
-					_ = subScanner.scanString(":")! /* !: The string contains a colon, so the scan cannot fail. */
+					let subToken = subScanner.xl_scanUpToString(":") ?? ""
+					_ = subScanner.xl_scanString(":")! /* !: The string contains a colon, so the scan cannot fail. */
 
 					let isFgColor: Bool
 					switch subToken {
@@ -477,7 +477,7 @@ public struct SGR : RawRepresentable, Hashable, CustomStringConvertible {
 							 * Note however, it might be possible to get the 58 case too (underline color), though because it is not part of the ODA it shouldn’t be valid with this notation. */
 							throw DummyError()
 					}
-					let colorFormat = subScanner.scanUpToString(":") ?? ""
+					let colorFormat = subScanner.xl_scanUpToString(":") ?? ""
 					switch colorFormat {
 						case "0", "":
 							guard isFgColor, subScanner.isAtEnd else {
@@ -499,10 +499,10 @@ public struct SGR : RawRepresentable, Hashable, CustomStringConvertible {
 					func scanParam() throws -> Int? {
 						if subScanner.isAtEnd {return nil}
 						else {
-							guard subScanner.scanString(":") != nil else {
+							guard subScanner.xl_scanString(":") != nil else {
 								throw DummyError()
 							}
-							guard let str = subScanner.scanUpToString(":") else {
+							guard let str = subScanner.xl_scanUpToString(":") else {
 								return nil
 							}
 							/* We assume “+1” is a valid value. */
@@ -579,9 +579,9 @@ public struct SGR : RawRepresentable, Hashable, CustomStringConvertible {
 				}
 				if let colorDestination = ColorDestination(rawValue: token) {
 					guard
-						scanner.scanCharacter() == Self.separatorChar,
-						let colorType = scanner.scanCharacter(),
-						scanner.scanCharacter() == Self.separatorChar
+						scanner.xl_scanCharacter() == Self.separatorChar,
+						let colorType = scanner.xl_scanCharacter(),
+						scanner.xl_scanCharacter() == Self.separatorChar
 					else {
 						throw DummyError()
 					}
@@ -600,19 +600,19 @@ public struct SGR : RawRepresentable, Hashable, CustomStringConvertible {
 							/* Wikipedia says empty values are treated as 0.
 							 * But Terminal for instance does not seem to know that.
 							 * We don’t care, we do like Wikipedia says. */
-							let r = try uint8(scanner.scanUpToString(String(Self.separatorChar)) ?? "0")
-							guard scanner.scanCharacter() == Self.separatorChar else {throw DummyError()}
-							let g = try uint8(scanner.scanUpToString(String(Self.separatorChar)) ?? "0")
-							guard scanner.scanCharacter() == Self.separatorChar else {throw DummyError()}
-							let b = try uint8(scanner.scanUpToString(String(Self.separatorChar)) ?? "0")
+							let r = try uint8(scanner.xl_scanUpToString(String(Self.separatorChar)) ?? "0")
+							guard scanner.xl_scanCharacter() == Self.separatorChar else {throw DummyError()}
+							let g = try uint8(scanner.xl_scanUpToString(String(Self.separatorChar)) ?? "0")
+							guard scanner.xl_scanCharacter() == Self.separatorChar else {throw DummyError()}
+							let b = try uint8(scanner.xl_scanUpToString(String(Self.separatorChar)) ?? "0")
 							switch colorDestination {
 								case .fg: self = .fgColorToRGB(red: r, green: g, blue: b); return
 								case .bg: self = .bgColorToRGB(red: r, green: g, blue: b); return
 								case .ul: self = .underlineColorToRGB(red: r, green: g, blue: b); return
 							}
 
 						case "5":
-							let v = try uint8(scanner.scanUpToString(String(Self.separatorChar)) ?? "0")
+							let v = try uint8(scanner.xl_scanUpToString(String(Self.separatorChar)) ?? "0")
 							switch colorDestination {
 								case .fg: self = .fgColorTo256PaletteValue(v); return
 								case .bg: self = .bgColorTo256PaletteValue(v); return
@@ -707,7 +707,7 @@ public struct SGR : RawRepresentable, Hashable, CustomStringConvertible {
 					default: throw DummyError()
 				}
 			} catch {
-				scanner.currentIndex = originalScannerIndex
+				scanner.compatibleScanLocation = originalScanLocation
 				return nil
 			}
 		}
@@ -756,18 +756,18 @@ public struct SGR : RawRepresentable, Hashable, CustomStringConvertible {
 	/* For symetry w/ SGR.Modifier init, but not really needed, at least for now. */
 	init?(scanner: Scanner) {
 		struct DummyError : Error {}
-		let originalScannerIndex = scanner.currentIndex
+		let originalScanLocation = scanner.compatibleScanLocation
 		do {
 			guard
-				scanner.scanCharacter() == Self.escapeChar,
-				scanner.scanCharacter() == Self.csiChar
+				scanner.xl_scanCharacter() == Self.escapeChar,
+				scanner.xl_scanCharacter() == Self.csiChar
 			else {
 				/* Not a CSI. */
 				throw DummyError()
 			}
 
-			let csiContent = scanner.scanUpToCharacters(from: Self.possibleFinalByte) ?? ""
-			guard scanner.scanCharacter() == Self.sgrEndChar else {
+			let csiContent = scanner.xl_scanUpToCharacters(from: Self.possibleFinalByte) ?? ""
+			guard scanner.xl_scanCharacter() == Self.sgrEndChar else {
 				/* Not an SGR. */
 				throw DummyError()
 			}
@@ -781,15 +781,15 @@ public struct SGR : RawRepresentable, Hashable, CustomStringConvertible {
 				/* A modifier has been parsed.
 				 * Either scan location is now at a semicolon or at the end.
 				 * If on semicolon we must consume it. */
-				let c = contentScanner.scanCharacter()
+				let c = contentScanner.xl_scanCharacter()
 				assert(c == Modifier.separatorChar)
 			}
 			guard contentScanner.isAtEnd else {
 				/* Not all modifiers parsed in the content. */
 				throw DummyError()
 			}
 		} catch {
-			scanner.currentIndex = originalScannerIndex
+			scanner.compatibleScanLocation = originalScanLocation
 			return nil
 		}
 	}

Sources/Scanner+OldOS.swift

@@ -0,0 +1,141 @@
+/*
+Copyright 2019 happn
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+import Foundation
+
+
+
+/* This is from XibLoc. */
+extension Scanner {
+	
+	enum CompatibleScanLocation {
+		case int(Int)
+		case index(String.Index)
+		/** Crashes if the enum contains an index. */
+		var intValue: Int {
+			guard case let .int(i) = self else {
+				fatalError("Asked for the int value but I have an index.")
+			}
+			return i
+		}
+		var indexValue: String.Index {
+			guard case let .index(i) = self else {
+				fatalError("Asked for the index value but I have an int.")
+			}
+			return i
+		}
+	}
+	
+	var compatibleScanLocation: CompatibleScanLocation {
+		get {
+#if canImport(Darwin)
+			if #available(macOS 10.15, tvOS 13.0, iOS 13.0, watchOS 6.0, *) {
+				return .index(currentIndex)
+			} else {
+				return .int(scanLocation)
+			}
+#else
+			return .index(currentIndex)
+#endif
+		}
+		set {
+#if canImport(Darwin)
+			if #available(macOS 10.15, tvOS 13.0, iOS 13.0, watchOS 6.0, *) {
+				currentIndex = newValue.indexValue
+			} else {
+				scanLocation = newValue.intValue
+			}
+#else
+			currentIndex = newValue.indexValue
+#endif
+		}
+	}
+	
+	func xl_scanString(_ string: String) -> String? {
+#if canImport(Darwin)
+		if #available(macOS 10.15, tvOS 13.0, iOS 13.0, watchOS 6.0, *) {
+			return scanString(string)
+		} else {
+			var result: NSString?
+			guard scanString(string, into: &result) else {return nil}
+			return result! as String
+		}
+#else
+		return scanString(string)
+#endif
+	}
+	
+	func xl_scanCharacter() -> Character? {
+#if canImport(Darwin)
+		if #available(macOS 10.15, tvOS 13.0, iOS 13.0, watchOS 6.0, *) {
+			return scanCharacter()
+		} else {
+			guard !isAtEnd else {
+				return nil
+			}
+			let utf16 = string.utf16
+			let characterStr = utf16[utf16.index(utf16.startIndex, offsetBy: scanLocation)..<utf16.index(utf16.startIndex, offsetBy: scanLocation + 1)]
+			var result: NSString?
+			guard scanString(String(characterStr)!, into: &result) else {return nil}
+			return Character(result! as String)
+		}
+#else
+		return scanCharacter()
+#endif
+	}
+	
+	func xl_scanUpToString(_ string: String) -> String? {
+#if canImport(Darwin)
+		if #available(macOS 10.15, tvOS 13.0, iOS 13.0, watchOS 6.0, *) {
+			return scanUpToString(string)
+		} else {
+			var result: NSString?
+			guard scanUpTo(string, into: &result) else {return nil}
+			return result! as String
+		}
+#else
+		return scanUpToString(string)
+#endif
+	}
+	
+	func xl_scanUpToCharacters(from characterSet: CharacterSet) -> String? {
+#if canImport(Darwin)
+		if #available(macOS 10.15, tvOS 13.0, iOS 13.0, watchOS 6.0, *) {
+			return scanUpToCharacters(from: characterSet)
+		} else {
+			var result: NSString?
+			guard scanUpToCharacters(from: characterSet, into: &result) else {return nil}
+			return result! as String
+		}
+#else
+		return scanUpToCharacters(from: characterSet)
+#endif
+	}
+	
+	func xl_scanCharacters(from set: CharacterSet) -> String? {
+#if canImport(Darwin)
+		if #available(macOS 10.15, tvOS 13.0, iOS 13.0, watchOS 6.0, *) {
+			return scanCharacters(from: set)
+		} else {
+			var result: NSString?
+			guard scanCharacters(from: set, into: &result) else {return nil}
+			return result! as String
+		}
+#else
+		return scanCharacters(from: set)
+#endif
+	}
+	
+}