lint files with SwiftLint

Author: Xiangyu Sun

Package.swift

@@ -9,7 +9,8 @@ let package = Package(
         // Products define the executables and libraries produced by a package, and make them visible to other packages.
         .library(
             name: "BowlingKit",
-            targets: ["BowlingKit"]),
+            targets: ["BowlingKit"]
+        ),
     ],
     dependencies: [
         // Dependencies declare other packages that this package depends on.
@@ -20,9 +21,11 @@ let package = Package(
         // Targets can depend on other targets in this package, and on products in packages which this package depends on.
         .target(
             name: "BowlingKit",
-            dependencies: []),
+            dependencies: []
+        ),
         .testTarget(
             name: "BowlingKitTests",
-            dependencies: ["BowlingKit"]),
+            dependencies: ["BowlingKit"]
+        ),
     ]
 )

Sources/BowlingKit/BowlingBot.swift

@@ -1,6 +1,6 @@
 //
 //  File.swift
-//  
+//
 //
 //  Created by 孙翔宇 on 21/06/2019.
 //
@@ -9,32 +9,32 @@ import Foundation
 
 public class BowlingBot {
     public private(set) var game: Game
-    
+
     public init() {
         game = Game()
     }
-    
+
     public func generateFullGame() throws {
         if game.isGameover {
             game = Game()
         }
-        
+
         while !game.isGameover {
             try rollNextBall()
         }
     }
-    
+
     @discardableResult
     public func rollNextBall() throws -> UInt {
         let pinsDown: UInt
-        if let lastFrame = game.frames.last, !lastFrame.isCompleted  {
-            pinsDown = UInt.random(in: 0...lastFrame.pinsLeft)
-            try game.rolledWith(pinsKnockedDown: UInt.random(in: 0...lastFrame.pinsLeft))
+        if let lastFrame = game.frames.last, !lastFrame.isCompleted {
+            pinsDown = UInt.random(in: 0 ... lastFrame.pinsLeft)
+            try game.rolledWith(pinsKnockedDown: UInt.random(in: 0 ... lastFrame.pinsLeft))
         } else {
-            pinsDown = UInt.random(in: 0...10)
-            try game.rolledWith(pinsKnockedDown: UInt.random(in: 0...10))
+            pinsDown = UInt.random(in: 0 ... 10)
+            try game.rolledWith(pinsKnockedDown: UInt.random(in: 0 ... 10))
         }
-        
+
         return pinsDown
     }
 }

Sources/BowlingKit/Frame.swift

@@ -9,71 +9,70 @@
 import Foundation
 
 public final class Frame {
-    
     public static let maxiumPinsCount: UInt = 10
     public var state: FrameState
-    
+
     public var calcualtedScore: UInt { state.calcualtedScore(self) }
-    
+
     public var isCompleted: Bool { state.isFrameCompleted(self) }
-    
+
     public var isCompletelyScored: Bool { state.canScore(self) }
-    
+
     weak var scoringFrame: Frame?
-    
+
     let isLastFrame: Bool
-    
+
     var pinsLeft: UInt { Frame.maxiumPinsCount - (pinsKnockedDown.first ?? 0) }
-    
+
     private(set) var pinsKnockedDown = [UInt]()
-    
+
     public init(lastFrame: Bool = false) {
-        self.isLastFrame = lastFrame
-        self.state = InitialState()
+        isLastFrame = lastFrame
+        state = InitialState()
     }
-    
+
     public func addPinsKnockedDown(_ count: UInt) { state.addPinsKnockedDown(count, frame: self) }
-    
+
     func addballsKnockedDown(count: UInt) { pinsKnockedDown.append(count) }
-    
+
     func getScoringFramePinsKnockedDown(ballIndex: Int) -> [UInt] {
         guard let scoringFrame = scoringFrame, ballIndex != 0 else { return [] }
-        
+
         let allFrames = scoringFrame.pinsKnockedDown + (scoringFrame.scoringFrame?.pinsKnockedDown ?? [])
-        
+
         let ballsKnockDownNeeded = allFrames.count - ballIndex
-        
+
         guard ballsKnockDownNeeded >= 0 else {
             return []
         }
         return Array(allFrames[..<ballIndex])
     }
-    
+
     func getFirstBallRolledState(pinsDown: UInt) -> FrameState {
         let state = OneBallState()
         state.addPinsKnockedDown(pinsDown, frame: self)
         return state
     }
-    
+
     func getStrikeState(pinsDown: UInt) -> FrameState {
         let state: FrameState = isLastFrame ? FinalFrameStrikeState() : StrikeState()
         state.addPinsKnockedDown(pinsDown, frame: self)
         return state
     }
-    
+
     func getSpareState(pinsDown: UInt) -> FrameState {
-        let state:FrameState = isLastFrame ? FinalFrameSpareState() : SpareState()
+        let state: FrameState = isLastFrame ? FinalFrameSpareState() : SpareState()
         state.addPinsKnockedDown(pinsDown, frame: self)
         return state
     }
-    
+
     func getMissedState(pinsDown: UInt) -> FrameState {
         let state = MissedState()
         state.addPinsKnockedDown(pinsDown, frame: self)
         return state
     }
 }
 
-extension Frame : CustomDebugStringConvertible {
+extension Frame: CustomDebugStringConvertible {
     public var debugDescription: String { pinsKnockedDown.debugDescription }
 }

Sources/BowlingKit/FrameState/FrameState.swift

@@ -19,40 +19,37 @@ public protocol FrameState {
 }
 
 public extension FrameState {
-    
     func isFrameCompleted(_ frame: Frame) -> Bool { frame.pinsKnockedDown.count == maximumBallCount }
-    
+
     var maximumBallCount: UInt { 2 }
-    
+
     var ballsRequiredForScoring: UInt { maximumBallCount }
-    
+
     func calcualtedScore(_ frame: Frame) -> UInt { ballsForScoring(frame)?.sum() ?? 0 }
-    
+
     func canScore(_ frame: Frame) -> Bool { ballsForScoring(frame)?.count == ballsRequiredForScoring }
-    
+
     func ballsForScoring(_ frame: Frame) -> [UInt]? { frame.pinsKnockedDown }
 }
 
 public protocol CompleteFrameState: FrameState {}
 public extension CompleteFrameState {
-    
     var ballsRequiredForScoring: UInt { 3 }
-    
+
     func addPinsKnockedDown(_ count: UInt, frame: Frame) {
         guard !isFrameCompleted(frame) else { return }
         frame.addballsKnockedDown(count: count)
     }
-    
+
     func ballsForScoring(_ frame: Frame) -> [UInt]? {
-        
         var frames = frame.pinsKnockedDown
-        
+
         let countOfBallsMissing = ballsRequiredForScoring - frames.count
-        
+
         if countOfBallsMissing > 0 {
             frames.append(contentsOf: frame.getScoringFramePinsKnockedDown(ballIndex: countOfBallsMissing))
         }
-        
+
         return frames
     }
 }
@@ -67,7 +64,6 @@ public struct StrikeState: CompleteFrameState {
     public var maximumBallCount: UInt { 1 }
 }
 
-
 public protocol FinalFrameState: CompleteFrameState {}
 public extension FinalFrameState {
     func isFrameCompleted(_ frame: Frame) -> Bool { canScore(frame) }

Sources/BowlingKit/FrameState/OneBallState.swift

@@ -10,7 +10,7 @@ import Foundation
 
 public struct OneBallState: FrameState {
     public func addPinsKnockedDown(_ count: UInt, frame: Frame) {
-         if count == frame.pinsLeft {
+        if count == frame.pinsLeft {
             frame.state = frame.getSpareState(pinsDown: count)
         } else {
             frame.state = frame.getMissedState(pinsDown: count)

Sources/BowlingKit/Game.swift

@@ -8,60 +8,59 @@
 
 import Foundation
 
-enum GameError : Error {
+enum GameError: Error {
     case gameFinished
 }
 
 public final class Game {
-    
     public static let maximumFrameCount: UInt = 10
-    
+
     public private(set) var frames = [Frame]()
-    
-    public var completelyScoredFames: [Frame] { frames.filter{ $0.isCompletelyScored } }
-    
+
+    public var completelyScoredFames: [Frame] { frames.filter { $0.isCompletelyScored } }
+
     public var frameIndexForNextBall: UInt {
         let currentFrameDelta: UInt = isNextFrameNew ? 1 : 0
         return min(Game.maximumFrameCount, UInt(frames.count) + currentFrameDelta)
     }
-    
+
     public var isGameover: Bool { completelyScoredFames.count >= Game.maximumFrameCount }
-    
+
     var isNextFrameNew: Bool { frames.isEmpty || frames.last?.isCompleted == true }
-    
+
     public init() {}
-    
+
     public func rolledWith(pinsKnockedDown: UInt) throws {
         guard !isGameover else { throw GameError.gameFinished }
 
         if let newFrame = makeNextFrame() {
             frames.append(newFrame)
         }
-        
+
         frames.last?.addPinsKnockedDown(pinsKnockedDown)
     }
-    
+
     public func rolledWith(pinsKnockedDownSequence: [UInt]) throws {
-        try pinsKnockedDownSequence.forEach{ try self.rolledWith(pinsKnockedDown: $0) }
+        try pinsKnockedDownSequence.forEach { try self.rolledWith(pinsKnockedDown: $0) }
     }
-    
+
     func makeNextFrame() -> Frame? {
         if isNextFrameNew {
-            let newFrame = Frame(lastFrame: frames.count == Game.maximumFrameCount - 1 )
-            
+            let newFrame = Frame(lastFrame: frames.count == Game.maximumFrameCount - 1)
+
             if frames.last?.state is StrikeState || frames.last?.state is SpareState {
                 frames.last?.scoringFrame = newFrame
             }
-            
+
             return newFrame
         }
-        
+
         return nil
     }
 }
 
 extension Game: CustomDebugStringConvertible {
     public var debugDescription: String {
-        return frames.compactMap{ $0.pinsKnockedDown }.debugDescription
+        frames.compactMap { $0.pinsKnockedDown }.debugDescription
     }
 }

Sources/BowlingKit/Scorer.swift

@@ -10,45 +10,44 @@ import Foundation
 
 public final class Scorer {
     private(set) var game: Game
-    
+
     /// returns the number of the frame containing the ball about to be rolled
     public var frameNumber: String { String(describing: game.frameIndexForNextBall) }
-    
+
     /// returns true when the tenth frame has been
     /// scored and false otherwise, and which causes the next roll to start a new
     /// game
     public var gameIsOver: Bool { game.isGameover }
-    
+
     /// returns the score in the game so far
-    public var scoreSoFar: String { String(describing: game.frames.lazy.map{ $0.calcualtedScore }.sum()) }
-    
+    public var scoreSoFar: String { String(describing: game.frames.lazy.map { $0.calcualtedScore }.sum()) }
+
     public init() {
-        self.game = Game()
+        game = Game()
     }
-    
+
     /// given the number of pins knocked down by a roll of the
     /// ball, returns an array whose length is the number of frames completely scored and whose contents are the cumulative scores for those frames
     /// - Parameter pinsKnockedDown: pins knocked down by a roll of the
     /// ball
     @discardableResult
     public func rolledWith(pinsKnockedDown: UInt) throws -> [UInt] {
-
         do {
             try game.rolledWith(pinsKnockedDown: pinsKnockedDown)
         } catch {
             game = Game()
             try game.rolledWith(pinsKnockedDown: pinsKnockedDown)
         }
-        
+
         return cuculativeScores(frames: game.completelyScoredFames)
     }
-    
+
     @discardableResult
     public func rolledWith(pinsKnockedDownSequence: [UInt]) throws -> [UInt] {
         try pinsKnockedDownSequence.compactMap { try self.rolledWith(pinsKnockedDown: $0) }.last ?? []
     }
-    
+
     private func cuculativeScores(frames: [Frame]) -> [UInt] {
-        frames.enumerated().map{ frames[...$0.0].lazy.map{ $0.calcualtedScore }.sum() }
+        frames.enumerated().map { frames[...$0.0].lazy.map { $0.calcualtedScore }.sum() }
     }
 }

Sources/BowlingKit/Utilities/UInt.swift

@@ -10,12 +10,12 @@ import Foundation
 
 extension Int {
     static func - (left: UInt, right: Int) -> Int {
-        return Int(left) - right
+        Int(left) - right
     }
 }
 
 extension Optional where Wrapped == Int {
     static func == (left: Int?, right: UInt) -> Bool {
-        return left == Int(right)
+        left == Int(right)
     }
 }