change: use swiftformat

CHANGELOG.md

@@ -2,5 +2,6 @@
 
 - [SwiftLint](https://github.com/realm/SwiftLint) with a .swiftlint.yml file. lint checks are done on CI
 - `Sendable` conformance to `Version` to satisfy build warnings when complete concurrency checks are enabled
+- [SwiftFormat](https://github.com/nicklockwood/SwiftFormat/tree/main) with a format file. lint checks are done on CI
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Package.swift

@@ -16,8 +16,8 @@ let package = Package(
             name: "VersionCompare",
             targets: [
                 "VersionCompare"
-                ]
-        ),
+            ]
+        )
     ],
     targets: [
         .target(
@@ -31,8 +31,8 @@ let package = Package(
             name: "VersionCompareTests",
             dependencies: [
                 "VersionCompare"
-                ]
-        ),
+            ]
+        )
     ],
     swiftLanguageVersions: [.v5]
 )

Sources/Helper/Character+Extensions.swift

@@ -5,7 +5,7 @@
 //  Created by Marius Felkner on 30.03.21.
 //
 
-internal extension Character {
+extension Character {
     var isZero: Bool {
         if self == "0" {
             return true

Sources/Helper/String+Regex.swift

@@ -5,7 +5,7 @@
 //  Created by Marius Felkner on 05.01.21.
 //
 
-internal extension String {
+extension String {
     var isAlphaNumericString: Bool {
         matches("^[a-zA-Z0-9-]+$")
     }

Sources/Helper/VersionValidationError.swift

@@ -11,6 +11,8 @@ enum VersionValidationError: Swift.Error {
     case invalidVersionIdentifier
 }
 
+// MARK: LocalizedError
+
 extension VersionValidationError: LocalizedError {
     var errorDescription: String? {
         switch self {

Sources/SemanticVersionComparable/BuildMetaData/BuildMetaData+ExpressibleByLiteral.swift

@@ -5,6 +5,8 @@
 //  Created by Marius Felkner on 12.03.21.
 //
 
+// MARK: - BuildMetaData + LosslessStringConvertible
+
 extension BuildMetaData: LosslessStringConvertible {
     public var description: String { value }
 
@@ -13,6 +15,8 @@ extension BuildMetaData: LosslessStringConvertible {
     }
 }
 
+// MARK: - BuildMetaData + ExpressibleByStringLiteral
+
 extension BuildMetaData: ExpressibleByStringLiteral {
     public init(stringLiteral value: StringLiteralType) {
         self.init(private: value)

Sources/SemanticVersionComparable/PrereleaseIdentifier/PrereleaseIdentifier+ExpressibleByLiteral.swift

@@ -5,6 +5,8 @@
 //  Created by Marius Felkner on 12.03.21.
 //
 
+// MARK: - PrereleaseIdentifier + LosslessStringConvertible
+
 extension PrereleaseIdentifier: LosslessStringConvertible {
     public var description: String { value }
 
@@ -13,16 +15,20 @@ extension PrereleaseIdentifier: LosslessStringConvertible {
     }
 }
 
+// MARK: - PrereleaseIdentifier + ExpressibleByStringLiteral
+
 extension PrereleaseIdentifier: ExpressibleByStringLiteral {
     public init(stringLiteral value: StringLiteralType) {
         self.init(private: value)
     }
 }
 
+// MARK: - PrereleaseIdentifier + ExpressibleByIntegerLiteral
+
 extension PrereleaseIdentifier: ExpressibleByIntegerLiteral {
     public init(integerLiteral value: IntegerLiteralType) {
         let absoluteInteger: Int = abs(value)
-        let unsignedInteger: UInt = UInt(absoluteInteger)
+        let unsignedInteger = UInt(absoluteInteger)
         self = .numeric(unsignedInteger)
     }
 }

Sources/SemanticVersionComparable/PrereleaseIdentifier/PrereleaseIdentifier.swift

@@ -35,7 +35,8 @@ public enum PrereleaseIdentifier: Comparable, Hashable {
 
     init(private string: String) {
         if string.isNumericString,
-           let numeric = UInt(string) {
+           let numeric = UInt(string)
+        {
             self = .numeric(numeric)
         } else if string.isAlphaNumericString {
             self = .alphaNumeric(string)

Sources/SemanticVersionComparable/SemanticVersionComparable+Comparable.swift

@@ -22,21 +22,25 @@ public extension SemanticVersionComparable {
         // non-pre-release lhs version is always >= than rhs version
         guard
             let lhspr = lhs.prerelease,
-            !lhspr.isEmpty else {
+            !lhspr.isEmpty
+        else {
             return false
         }
 
         // same goes for rhs vise versa
         guard
             let rhspr = rhs.prerelease,
-            !rhspr.isEmpty  else {
+            !rhspr.isEmpty
+        else {
             return true
         }
 
         // compare content of pre-release identifier
         for (untypedLhs, untypedRhs) in zip(lhspr, rhspr) {
             // if both pre-release identifier are equal, skip the now obsolete comparison
-            if untypedLhs == untypedRhs { continue }
+            if untypedLhs == untypedRhs {
+                continue
+            }
 
             // cast identifiers to int or string as Any
             let typedLhs: Any = Int(untypedLhs.value) ?? untypedLhs.value

Sources/SemanticVersionComparable/SemanticVersionComparable.swift

@@ -56,7 +56,7 @@ public extension SemanticVersionComparable {
     /// Lhs must be a lower version to return a valid result. Otherwise `.noUpdate` will be
     /// returned regardless of the difference between the two version objects.
     ///
-    /// - Parameter version: A version object that conforms to the `SemanticVersionComparable` protocol that will be 
+    /// - Parameter version: A version object that conforms to the `SemanticVersionComparable` protocol that will be
     /// compared.
     ///
     /// - Returns: A `VersionCompareResult` as the severity of the update.
@@ -68,8 +68,9 @@ public extension SemanticVersionComparable {
             if lhs < rhs {
                 return .prerelease
             }
-            if lhs.build != rhs.build &&
-               lhs.prereleaseIdentifierString == rhs.prereleaseIdentifierString {
+            if lhs.build != rhs.build,
+               lhs.prereleaseIdentifierString == rhs.prereleaseIdentifierString
+            {
                 return .build
             }
 
@@ -148,14 +149,14 @@ public extension SemanticVersionComparable {
     /// The pre-release identifier as a string if available.
     var prereleaseIdentifierString: String? {
         prerelease?
-            .compactMap { $0.value }
+            .compactMap(\.value)
             .joined(separator: ".")
     }
 
     /// The build-meta-data as a string if available.
     var buildMetaDataString: String? {
         build?
-            .compactMap { $0.value }
+            .compactMap(\.value)
             .joined(separator: ".")
     }
 }

Sources/Version+Bundle.swift

@@ -8,9 +8,9 @@
 import Foundation
 
 public extension Bundle {
-     /// The version of the current bundle.
-     ///
-     /// - Note: Uses the key `CFBundleShortVersionString` for retrieving version values.
+    /// The version of the current bundle.
+    ///
+    /// - Note: Uses the key `CFBundleShortVersionString` for retrieving version values.
     var shortVersion: Version? {
         guard let versionString: String = infoDictionary?["CFBundleShortVersionString"] as? String else {
             return nil
@@ -26,10 +26,11 @@ public extension Bundle {
     var version: Version? {
         guard
             let versionString: String = infoDictionary?["CFBundleShortVersionString"] as? String,
-            let buildString: String = infoDictionary?["CFBundleVersion"] as? String else {
+            let buildString: String = infoDictionary?["CFBundleVersion"] as? String
+        else {
             return nil
         }
-        let fullVersionString: String = "\(versionString)+\(buildString)"
+        let fullVersionString = "\(versionString)+\(buildString)"
         let version: Version? = Version(fullVersionString)
 
         return version

Sources/Version+OS.swift

@@ -12,7 +12,7 @@ public extension ProcessInfo {
     @available(macOS, introduced: 10.10)
     var comparableOperatingSystemVersion: Version {
         let osVersion: OperatingSystemVersion = operatingSystemVersion
-        let version: Version = Version(
+        let version = Version(
             major: UInt(osVersion.majorVersion),
             minor: UInt(osVersion.minorVersion),
             patch: UInt(osVersion.patchVersion)

Sources/Version+StringInitializer.swift

@@ -5,6 +5,8 @@
 //  Created by Marius Felkner on 05.01.21.
 //
 
+// MARK: - Version + LosslessStringConvertible
+
 extension Version: LosslessStringConvertible {
     public var description: String { absoluteString }
 
@@ -18,6 +20,8 @@ extension Version: LosslessStringConvertible {
     }
 }
 
+// MARK: - Version + ExpressibleByStringLiteral
+
 extension Version: ExpressibleByStringLiteral {
     /// Creates a new version from a string literal.
     ///
@@ -28,6 +32,8 @@ extension Version: ExpressibleByStringLiteral {
     }
 }
 
+// MARK: - Version + ExpressibleByStringInterpolation
+
 extension Version: ExpressibleByStringInterpolation {
     /// Creates a new version from a string interpolation.
     ///

Sources/Version.swift

@@ -104,11 +104,12 @@ public struct Version: Sendable, SemanticVersionComparable {
         let versionSplitBuild: [String.SubSequence] = string.split(separator: "+", omittingEmptySubsequences: false)
 
         // check if string does not contain only build-meta-data e.g. "+123" or falsely "+123+something"
-        let maxNumberOfSplits: Int = 2
+        let maxNumberOfSplits = 2
         guard
             !versionSplitBuild.isEmpty,
             versionSplitBuild.count <= maxNumberOfSplits,
-            let versionPrereleaseString = versionSplitBuild.first else {
+            let versionPrereleaseString = versionSplitBuild.first
+        else {
             return nil
         }
 
@@ -120,13 +121,14 @@ public struct Version: Sendable, SemanticVersionComparable {
         guard
             !versionSplitPrerelease.isEmpty,
             let versionStringElement = versionSplitPrerelease.first,
-            !versionStringElement.isEmpty else {
+            !versionStringElement.isEmpty
+        else {
             return nil
         }
 
         // check that the version string has the correct SemVer format which are 0 and positive numbers in the form
         // of `x`, `x.x`or `x.x.x`.
-        let versionString: String = String(versionStringElement)
+        let versionString = String(versionStringElement)
         guard versionString.matchesSemVerFormat() else {
             return nil
         }
@@ -141,7 +143,8 @@ public struct Version: Sendable, SemanticVersionComparable {
                 guard
                     let element = UInt($0),
                     let firstCharacter = $0.first,
-                    !(firstCharacter.isZero && $0.count > 1) else {
+                    !(firstCharacter.isZero && $0.count > 1)
+                else {
                     throw VersionValidationError.invalidVersionIdentifier
                 }
 
@@ -153,16 +156,16 @@ public struct Version: Sendable, SemanticVersionComparable {
         }
 
         // map valid identifiers to corresponding version identifier
-        self.major = safeIdentifiers[0]
-        self.minor = safeIdentifiers.indices.contains(1) ? safeIdentifiers[1] : nil
+        major = safeIdentifiers[0]
+        minor = safeIdentifiers.indices.contains(1) ? safeIdentifiers[1] : nil
         // swiftlint:disable:next no_magic_numbers
-        self.patch = safeIdentifiers.indices.contains(2) ? safeIdentifiers[2] : nil
+        patch = safeIdentifiers.indices.contains(2) ? safeIdentifiers[2] : nil
 
         // extract pre-release identifier if available
         if versionSplitPrerelease.indices.contains(1) {
             versionSplitPrerelease.removeFirst(1)
             let prereleaseSubstring: String = versionSplitPrerelease.joined(separator: "-")
-            self.prerelease = String(prereleaseSubstring)
+            prerelease = String(prereleaseSubstring)
                 .split(separator: ".")
                 .map(String.init)
                 .compactMap {
@@ -175,20 +178,22 @@ public struct Version: Sendable, SemanticVersionComparable {
             // if a pre-release identifier element is initialized as .unkown, we can savely assume that the given
             // string is not a valid  `SemVer` version string.
             if
-                let prerelease = self.prerelease,
-                prerelease.contains(where: { $0 == .unknown }) {
+                let prerelease,
+                prerelease.contains(where: { $0 == .unknown })
+            {
                 return nil
             }
         } else {
             // not pre-release identifier has been found
-            self.prerelease = nil
+            prerelease = nil
         }
 
         // extract build-meta-data identifier if available
         if
             versionSplitBuild.indices.contains(1),
-            let buildSubstring = versionSplitBuild.last {
-            self.build = String(buildSubstring)
+            let buildSubstring = versionSplitBuild.last
+        {
+            build = String(buildSubstring)
                 .split(separator: ".")
                 .map(String.init)
                 .compactMap {
@@ -197,13 +202,14 @@ public struct Version: Sendable, SemanticVersionComparable {
             // finding an .unkown element means that the given string is not conform to `SemVer` since it is no
             // alphaNumeric or a digit
             if
-                let build = self.build,
-                build.contains(where: { $0 == .unknown }) {
+                let build,
+                build.contains(where: { $0 == .unknown })
+            {
                 return nil
             }
         } else {
             // no build-meta-data has been found
-            self.build = nil
+            build = nil
         }
     }
 }
@@ -212,9 +218,11 @@ public struct Version: Sendable, SemanticVersionComparable {
 
 public extension Version {
     /// An initial version representing the string `0.0.0`.
-    static var initial: Version = Version(major: 0, minor: 0, patch: 0)
+    static var initial: Version = .init(major: 0, minor: 0, patch: 0)
 }
 
+// MARK: CustomDebugStringConvertible
+
 extension Version: CustomDebugStringConvertible {
     public var debugDescription: String { absoluteString }
 }