Remove swift logging when

Package.swift

@@ -12,19 +12,9 @@ let package = Package(
       targets: ["FelinePine"]
     )
   ],
-  dependencies: [
-    .package(url: "https://github.com/apple/swift-log.git", from: "1.0.0")
-  ],
   targets: [
     .target(
       name: "FelinePine",
-      dependencies: [
-        .product(
-          name: "Logging",
-          package: "swift-log",
-          condition: .when(platforms: [.linux, .android, .wasi, .windows])
-        )
-      ],
       swiftSettings: [
         SwiftSetting.enableUpcomingFeature("BareSlashRegexLiterals"),
         SwiftSetting.enableUpcomingFeature("ConciseMagicFile"),

Sources/FelinePine/Feline.swift

@@ -28,9 +28,10 @@
 //
 
 import Foundation
+
 #if canImport(os)
   import os
-#else
+#elseif canImport(Logging)
   import Logging
 #endif
 
@@ -45,9 +46,11 @@ public protocol Feline {
   }
 }
 
-extension Feline where Self: Pine {
-  /// Use the ``loggingCategory`` to define the shared logger for type.
-  public static var logger: Logger {
-    LoggingSystemType.logger(forCategory: loggingCategory)
+#if canImport(os) || canImport(Logging)
+  extension Feline where Self: Pine {
+    /// Use the ``loggingCategory`` to define the shared logger for type.
+    public static var logger: Logger {
+      LoggingSystemType.logger(forCategory: loggingCategory)
+    }
   }
-}
+#endif

Sources/FelinePine/Loggable.swift

@@ -29,6 +29,13 @@
 
 import Foundation
 
+#if canImport(os) || canImport(Logging)
+  public typealias FelinePineProtocol = Feline & Pine
+#else
+  public typealias FelinePineProtocol = Feline
+#endif
+
 /// Loggable type for a ``LoggingSystem``.
-public protocol Loggable<LoggingSystemType>: Feline, Pine
+public protocol Loggable<LoggingSystemType>: FelinePineProtocol
+
   where LoggingSystemType: LoggingSystem {}

Sources/FelinePine/Logger+LoggerCategory.swift

@@ -30,20 +30,22 @@
 import Foundation
 #if canImport(os)
   import os
-#else
+#elseif canImport(Logging)
   import Logging
 #endif
 
-extension Logger {
-  internal init<Category: RawRepresentable>(
-    subsystem: String,
-    category: Category
-  ) where Category.RawValue == String {
-    #if canImport(os)
-      self.init(subsystem: subsystem, category: category.rawValue)
-    #else
-      self.init(label: subsystem)
-      self[metadataKey: "category"] = "\(category)"
-    #endif
+#if canImport(os) || canImport(Logging)
+  extension Logger {
+    internal init<Category: RawRepresentable>(
+      subsystem: String,
+      category: Category
+    ) where Category.RawValue == String {
+      #if canImport(os)
+        self.init(subsystem: subsystem, category: category.rawValue)
+      #else
+        self.init(label: subsystem)
+        self[metadataKey: "category"] = "\(category)"
+      #endif
+    }
   }
-}
+#endif

Sources/FelinePine/Logger.swift

@@ -33,7 +33,7 @@
   import os.log
   /// Standard os.log Logger
   public typealias Logger = os.Logger
-#else
+#elseif canImport(Logging)
   import Logging
   /// swift-log Logging.Logger
   public typealias Logger = Logging.Logger

Sources/FelinePine/LoggingSystem+LoggingSystemRepository.swift

@@ -0,0 +1,114 @@
+//
+//  LoggingSystem+LoggingSystemRepository.swift
+//  FelinePine
+//
+//  Created by Leo Dion.
+//  Copyright © 2024 BrightDigit.
+//
+//  Permission is hereby granted, free of charge, to any person
+//  obtaining a copy of this software and associated documentation
+//  files (the “Software”), to deal in the Software without
+//  restriction, including without limitation the rights to use,
+//  copy, modify, merge, publish, distribute, sublicense, and/or
+//  sell copies of the Software, and to permit persons to whom the
+//  Software is furnished to do so, subject to the following
+//  conditions:
+//
+//  The above copyright notice and this permission notice shall be
+//  included in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+//  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+//  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+//  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+//  OTHER DEALINGS IN THE SOFTWARE.
+//
+
+import Foundation
+#if canImport(os)
+  import os
+#elseif canImport(Logging)
+  import Logging
+#endif
+
+// swiftlint:disable strict_fileprivate
+private class LoggingSystemRepository: @unchecked Sendable {
+  fileprivate static let shared = LoggingSystemRepository()
+
+  private let lock = NSRecursiveLock()
+  private var items = [String: Any]()
+
+  private init(items: [String: Any] = [String: Any]()) {
+    self.items = items
+  }
+
+  #if canImport(os) || canImport(Logging)
+    fileprivate func loggingSystem<LoggingSystemType: LoggingSystem>(
+      for system: LoggingSystemType.Type,
+      using value: @autoclosure () -> [LoggingSystemType.Category: Logger]
+    ) -> [LoggingSystemType.Category: Logger] {
+      let anyItem = lock.withLock {
+        items[system.identifier]
+      }
+      if let item = anyItem as? [LoggingSystemType.Category: Logger] {
+        return item
+      } else {
+        assert(anyItem == nil)
+        return lock.withLock {
+          let value = value()
+          items[system.identifier] = value
+          return value
+        }
+      }
+    }
+  #endif
+}
+
+// swiftlint:enable strict_fileprivate
+
+extension LoggingSystem {
+  // swiftlint:disable:next missing_docs
+  public static var identifier: String {
+    String(reflecting: Self.self)
+  }
+
+  /// By default, this is `Bundle.main.bundleIdentifier`.
+  public static var subsystem: String {
+    #if canImport(os)
+      Bundle.main.bundleIdentifier ?? identifier
+    #else
+      identifier
+    #endif
+  }
+}
+
+#if canImport(os) || canImport(Logging)
+  extension LoggingSystem where Category: CaseIterable {
+    private static var loggers: [Category: Logger] {
+      LoggingSystemRepository.shared.loggingSystem(
+        for: Self.self,
+        using: defaultLoggers()
+      )
+    }
+
+    /// If ``Category`` implements `CaseIterable`, ``LoggingSystem`` can automatically
+    /// iterate over the cases and automatically create the ``Logger`` objects needed.
+    public static func logger(forCategory category: Category) -> Logger {
+      guard let logger = loggers[category] else {
+        preconditionFailure("missing logger")
+      }
+      return logger
+    }
+
+    private static func defaultLoggers() -> [Category: Logger] {
+      .init(
+        uniqueKeysWithValues: Category.allCases.map {
+          ($0, Logger(subsystem: Self.subsystem, category: $0))
+        }
+      )
+    }
+  }
+#endif

Sources/FelinePine/LoggingSystem.swift

@@ -30,43 +30,10 @@
 import Foundation
 #if canImport(os)
   import os
-#else
+#elseif canImport(Logging)
   import Logging
 #endif
 
-// swiftlint:disable strict_fileprivate
-private class LoggingSystemRepository: @unchecked Sendable {
-  fileprivate static let shared = LoggingSystemRepository()
-
-  private let lock = NSRecursiveLock()
-  private var items = [String: Any]()
-
-  private init(items: [String: Any] = [String: Any]()) {
-    self.items = items
-  }
-
-  fileprivate func loggingSystem<LoggingSystemType: LoggingSystem>(
-    for system: LoggingSystemType.Type,
-    using value: @autoclosure () -> [LoggingSystemType.Category: Logger]
-  ) -> [LoggingSystemType.Category: Logger] {
-    let anyItem = lock.withLock {
-      items[system.identifier]
-    }
-    if let item = anyItem as? [LoggingSystemType.Category: Logger] {
-      return item
-    } else {
-      assert(anyItem == nil)
-      return lock.withLock {
-        let value = value()
-        items[system.identifier] = value
-        return value
-      }
-    }
-  }
-}
-
-// swiftlint:enable strict_fileprivate
-
 /// Defines the logging categories for your application.
 public protocol LoggingSystem {
   /// Logging categories available to types in the application
@@ -79,47 +46,8 @@ public protocol LoggingSystem {
   /// Subsystem to use for each ``Logger``.
   /// By default, this is `Bundle.main.bundleIdentifier`.
   static var subsystem: String { get }
-
-  /// Fetches the correct logger based on the category.
-  static func logger(forCategory category: Category) -> Logger
-}
-
-extension LoggingSystem {
-  // swiftlint:disable:next missing_docs
-  public static var identifier: String {
-    String(reflecting: Self.self)
-  }
-
-  /// By default, this is `Bundle.main.bundleIdentifier`.
-  public static var subsystem: String {
-    #if canImport(os)
-      // swiftlint:disable:next force_unwrapping
-      Bundle.main.bundleIdentifier!
-    #else
-      identifier
-    #endif
-  }
-}
-
-extension LoggingSystem where Category: CaseIterable {
-  private static var loggers: [Category: Logger] {
-    LoggingSystemRepository.shared.loggingSystem(for: Self.self, using: defaultLoggers())
-  }
-
-  /// If ``Category`` implements `CaseIterable`, ``LoggingSystem`` can automatically
-  /// iterate over the cases and automatically create the ``Logger`` objects needed.
-  public static func logger(forCategory category: Category) -> Logger {
-    guard let logger = loggers[category] else {
-      preconditionFailure("missing logger")
-    }
-    return logger
-  }
-
-  private static func defaultLoggers() -> [Category: Logger] {
-    .init(
-      uniqueKeysWithValues: Category.allCases.map {
-        ($0, Logger(subsystem: Self.subsystem, category: $0))
-      }
-    )
-  }
+  #if canImport(os) || canImport(Logging)
+    /// Fetches the correct logger based on the category.
+    static func logger(forCategory category: Category) -> Logger
+  #endif
 }

Sources/FelinePine/Pine.swift

@@ -30,16 +30,18 @@
 import Foundation
 #if canImport(os)
   import os
-#else
+#elseif canImport(Logging)
   import Logging
 #endif
 
-/// Defines a shared logger for the type.
-///
-/// Provides a shared ``Logger`` to use in this type.
-public protocol Pine {
-  /// Shared logger for Type.
-  static var logger: Logger {
-    get
+#if canImport(os) || canImport(Logging)
+  /// Defines a shared logger for the type.
+  ///
+  /// Provides a shared ``Logger`` to use in this type.
+  public protocol Pine {
+    /// Shared logger for Type.
+    static var logger: Logger {
+      get
+    }
   }
-}
+#endif

Tests/FelinePineTests/FelinePineTests.swift

@@ -31,8 +31,12 @@
 import XCTest
 
 internal final class FelinePineTests: XCTestCase {
-  internal func testLogger() {
-    _ = MockType.logger
-    XCTAssert(true)
+  internal func testLogger() throws {
+    #if canImport(os) || canImport(Logging)
+      _ = MockType.logger
+      XCTAssert(true)
+    #else
+      throw XCTSkip("No Logger available.")
+    #endif
   }
 }

Tests/FelinePineTests/LoggingSystemTests.swift

@@ -44,9 +44,13 @@ internal final class LoggingSystemTests: XCTestCase {
     }
   }
 
-  internal func testLogger() {
-    for category in MockSystem.Category.allCases {
-      _ = MockSystem.logger(forCategory: category)
-    }
+  internal func testLogger() throws {
+    #if canImport(os) || canImport(Logging)
+      for category in MockSystem.Category.allCases {
+        _ = MockSystem.logger(forCategory: category)
+      }
+    #else
+      throw XCTSkip("Logger not available.")
+    #endif
   }
 }