formatted

Author: btoms20

Package.swift

@@ -19,37 +19,40 @@ let package = Package(
     name: "swift-libp2p-mplex",
     platforms: [
         .macOS(.v10_15),
-        .iOS(.v13)
+        .iOS(.v13),
     ],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.
         .library(
             name: "LibP2PMPLEX",
-            targets: ["LibP2PMPLEX"]),
+            targets: ["LibP2PMPLEX"]
+        )
     ],
     dependencies: [
         // Dependencies declare other packages that this package depends on.
-        
+
         // LibP2P Core Modules
         .package(url: "https://github.com/swift-libp2p/swift-libp2p.git", .upToNextMinor(from: "0.1.0")),
-        
+
         // NIO Test Utils
         .package(url: "https://github.com/apple/swift-nio.git", from: "2.0.0"),
-        
+
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
         // Targets can depend on other targets in this package, and on products in packages this package depends on.
         .target(
             name: "LibP2PMPLEX",
             dependencies: [
-                .product(name: "LibP2P", package: "swift-libp2p"),
-            ]),
+                .product(name: "LibP2P", package: "swift-libp2p")
+            ]
+        ),
         .testTarget(
             name: "LibP2PMPLEXTests",
             dependencies: [
                 "LibP2PMPLEX",
                 .product(name: "NIOTestUtils", package: "swift-nio"),
-            ]),
+            ]
+        ),
     ]
 )

Sources/LibP2PMPLEX/LibP2PMPLEX.swift

@@ -12,32 +12,32 @@
 //
 //===----------------------------------------------------------------------===//
 
-import NIO
 import LibP2P
 import LibP2PCore
+import NIO
 
 protocol MessageExtractable {
     func messageBytes() -> ByteBuffer
 }
 
-protocol MessageExtractableHandler:ChannelInboundHandler where InboundOut:MessageExtractable { }
+protocol MessageExtractableHandler: ChannelInboundHandler where InboundOut: MessageExtractable {}
 
 public struct MPLEX: MuxerUpgrader {
-    
-    public static let key:String = MPLEXStreamMultiplexer.protocolCodec
-    let application:Application
+
+    public static let key: String = MPLEXStreamMultiplexer.protocolCodec
+    let application: Application
 
     public func upgradeConnection(_ conn: Connection, muxedPromise: EventLoopPromise<Muxer>) -> EventLoopFuture<Void> {
-        return conn.channel.pipeline.addHandlers(
+        conn.channel.pipeline.addHandlers(
             [
                 ByteToMessageHandler(MPLEXFrameDecoder()),
                 MessageToByteHandler(MPLEXFrameEncoder()),
-                MPLEXStreamMultiplexer(connection: conn, muxedPromise: muxedPromise, supportedProtocols: [])
+                MPLEXStreamMultiplexer(connection: conn, muxedPromise: muxedPromise, supportedProtocols: []),
             ],
             position: .last
         )
     }
-    
+
     public func printSelf() {
         application.logger.notice("Hi I'm MPLEX v6.7.0")
     }

Sources/LibP2PMPLEX/MPLEX/MPLEXErrorCode.swift

@@ -33,7 +33,7 @@ public struct MPLEXErrorCode {
     /// The underlying network representation of the error code.
     public var networkCode: Int {
         get {
-            return Int(self._networkCode)
+            Int(self._networkCode)
         }
         set {
             self._networkCode = UInt32(newValue)
@@ -93,9 +93,9 @@ public struct MPLEXErrorCode {
 
 }
 
-extension MPLEXErrorCode: Equatable { }
+extension MPLEXErrorCode: Equatable {}
 
-extension MPLEXErrorCode: Hashable { }
+extension MPLEXErrorCode: Hashable {}
 
 extension MPLEXErrorCode: CustomDebugStringConvertible {
     public var debugDescription: String {
@@ -129,28 +129,28 @@ extension MPLEXErrorCode: CustomDebugStringConvertible {
     }
 }
 
-public extension UInt32 {
+extension UInt32 {
     /// Create a 32-bit integer corresponding to the given `MPLEXErrorCode`.
-    init(mplexErrorCode code: MPLEXErrorCode) {
+    public init(mplexErrorCode code: MPLEXErrorCode) {
         self = code._networkCode
     }
 }
 
-public extension Int {
+extension Int {
     /// Create an integer corresponding to the given `MPLEXErrorCode`.
-    init(mplexErrorCode code: MPLEXErrorCode) {
+    public init(mplexErrorCode code: MPLEXErrorCode) {
         self = code.networkCode
     }
 }
 
-public extension ByteBuffer {
+extension ByteBuffer {
     /// Serializes a `MPLEXErrorCode` into a `ByteBuffer` in the appropriate endianness
     /// for use in MPLEX.
     ///
     /// - parameters:
     ///     - code: The `MPLEXErrorCode` to serialize.
     /// - returns: The number of bytes written.
-    mutating func write(mplexErrorCode code: MPLEXErrorCode) -> Int {
-        return self.writeInteger(UInt32(mplexErrorCode: code))
+    public mutating func write(mplexErrorCode code: MPLEXErrorCode) -> Int {
+        self.writeInteger(UInt32(mplexErrorCode: code))
     }
 }

Sources/LibP2PMPLEX/MPLEX/MPLEXErrors.swift

@@ -26,29 +26,34 @@
 //
 //===----------------------------------------------------------------------===//
 
-public protocol NIOMPLEXError: Equatable, Error { }
+public protocol NIOMPLEXError: Equatable, Error {}
 
-public enum MuxerError:Error {
+public enum MuxerError: Error {
     case custom(String)
 }
 
 /// Errors that NIO raises when handling MPLEX connections.
 public enum NIOMPLEXErrors {
 
     public static func noSuchStream(streamID: MPLEXStreamID, file: String = #file, line: UInt = #line) -> NoSuchStream {
-        return NoSuchStream(streamID: streamID, file: file, line: line)
+        NoSuchStream(streamID: streamID, file: file, line: line)
     }
-    
-    public static func streamClosed(streamID: MPLEXStreamID, errorCode: MPLEXErrorCode, file: String = #file, line: UInt = #line) -> StreamClosed {
-        return StreamClosed(streamID: streamID, errorCode: errorCode, file: file, line: line)
+
+    public static func streamClosed(
+        streamID: MPLEXStreamID,
+        errorCode: MPLEXErrorCode,
+        file: String = #file,
+        line: UInt = #line
+    ) -> StreamClosed {
+        StreamClosed(streamID: streamID, errorCode: errorCode, file: file, line: line)
     }
-    
+
     public static func noStreamIDAvailable(file: String = #file, line: UInt = #line) -> NoStreamIDAvailable {
-        return NoStreamIDAvailable(file: file, line: line)
+        NoStreamIDAvailable(file: file, line: line)
     }
 
     public static func streamError(streamID: MPLEXStreamID, baseError: Error) -> StreamError {
-        return StreamError(streamID: streamID, baseError: baseError)
+        StreamError(streamID: streamID, baseError: baseError)
     }
 
     /// An attempt was made to issue a write on a stream that does not exist.
@@ -69,8 +74,8 @@ public enum NIOMPLEXErrors {
             self.location = _location(file: file, line: line)
         }
 
-        public static func ==(lhs: NoSuchStream, rhs: NoSuchStream) -> Bool {
-            return lhs.streamID == rhs.streamID
+        public static func == (lhs: NoSuchStream, rhs: NoSuchStream) -> Bool {
+            lhs.streamID == rhs.streamID
         }
     }
 
@@ -96,8 +101,8 @@ public enum NIOMPLEXErrors {
             self.location = _location(file: file, line: line)
         }
 
-        public static func ==(lhs: StreamClosed, rhs: StreamClosed) -> Bool {
-            return lhs.streamID == rhs.streamID && lhs.errorCode == rhs.errorCode
+        public static func == (lhs: StreamClosed, rhs: StreamClosed) -> Bool {
+            lhs.streamID == rhs.streamID && lhs.errorCode == rhs.errorCode
         }
     }
 
@@ -108,7 +113,7 @@ public enum NIOMPLEXErrors {
 
         /// The location where the error was thrown.
         public var location: String {
-            return _location(file: self.file, line: self.line)
+            _location(file: self.file, line: self.line)
         }
 
         @available(*, deprecated, renamed: "noStreamIDAvailable")
@@ -121,8 +126,8 @@ public enum NIOMPLEXErrors {
             self.line = line
         }
 
-        public static func ==(lhs: NoStreamIDAvailable, rhs: NoStreamIDAvailable) -> Bool {
-            return true
+        public static func == (lhs: NoStreamIDAvailable, rhs: NoStreamIDAvailable) -> Bool {
+            true
         }
     }
 
@@ -143,7 +148,7 @@ public enum NIOMPLEXErrors {
             }
 
             func copy() -> Storage {
-                return Storage(
+                Storage(
                     streamID: self.streamID,
                     baseError: self.baseError
                 )
@@ -160,7 +165,7 @@ public enum NIOMPLEXErrors {
 
         public var baseError: Error {
             get {
-                return self.storage.baseError
+                self.storage.baseError
             }
             set {
                 self.copyStorageIfNotUniquelyReferenced()
@@ -170,7 +175,7 @@ public enum NIOMPLEXErrors {
 
         public var streamID: MPLEXStreamID {
             get {
-                return self.storage.streamID
+                self.storage.streamID
             }
             set {
                 self.copyStorageIfNotUniquelyReferenced()
@@ -179,7 +184,7 @@ public enum NIOMPLEXErrors {
         }
 
         public var description: String {
-            return "StreamError(streamID: \(self.streamID), baseError: \(self.baseError))"
+            "StreamError(streamID: \(self.streamID), baseError: \(self.baseError))"
         }
 
         fileprivate init(streamID: MPLEXStreamID, baseError: Error) {
@@ -188,7 +193,6 @@ public enum NIOMPLEXErrors {
     }
 }
 
-
 /// This enum covers errors that are thrown internally for messaging reasons. These should
 /// not leak.
 internal enum InternalError: Error {
@@ -197,10 +201,10 @@ internal enum InternalError: Error {
     case codecError(code: MPLEXErrorCode)
 }
 
-extension InternalError: Hashable { }
+extension InternalError: Hashable {}
 
 private func _location(file: String, line: UInt) -> String {
-    return "\(file):\(line)"
+    "\(file):\(line)"
 }
 
 private final class StringAndLocationStorage: Equatable {
@@ -209,7 +213,7 @@ private final class StringAndLocationStorage: Equatable {
     var line: UInt
 
     var location: String {
-        return _location(file: self.file, line: self.line)
+        _location(file: self.file, line: self.line)
     }
 
     init(_ value: String, file: String, line: UInt) {
@@ -219,11 +223,11 @@ private final class StringAndLocationStorage: Equatable {
     }
 
     func copy() -> StringAndLocationStorage {
-        return StringAndLocationStorage(self.value, file: self.file, line: self.line)
+        StringAndLocationStorage(self.value, file: self.file, line: self.line)
     }
 
-    static func ==(lhs: StringAndLocationStorage, rhs: StringAndLocationStorage) -> Bool {
+    static func == (lhs: StringAndLocationStorage, rhs: StringAndLocationStorage) -> Bool {
         // Only compare the value. The 'file' is not relevant here.
-        return lhs.value == rhs.value
+        lhs.value == rhs.value
     }
 }