lyzkov / sinkemall Goto Github PK

An error handling reactive extension for fine-grained control over "Abort, Retry, Fail?" inspired by the battleship game.

License: MIT License

Ruby 13.70% Swift 86.30%

rxswift rxswift-extensions abort retry fail error-ha

sinkemall's Introduction

SinkEmAll

An error handling reactive extension for fine-grained control over Abort, Retry, Fail?

Battleship (also Battleships or Sea Battle) is a guessing game for two players. It is played on ruled grids (paper or board) on which each player's fleet of ships (including battleships) are marked. The locations of the fleets are concealed from the other player. Players alternate turns calling "shots" at the other player's ships, and the objective of the game is to destroy the opposing player's fleet.

Usage

SinkEmAll extends the way of handling errors in RxSwift. It brings (A)bort, (R)etry, (F)ail? pattern back to the game. Yes, that's the battleship game!

    /// Definition of a single attempt of handling error.
    /// That's the battleship game: you can miss, hit, or sink on target.
    ///
    /// - miss: Attempt the operation again. (R)etry
    /// - hit: Throw an error to the next handler in the chain of responsibility. (A)bort or (I)gnore
    /// - sink: Gracefully recover from an error. (F)ail
    public enum Shot {
        case miss
        case hit(Error)
        case sink
    }

Therefore, you can implement ErrorShooting protocol in order to take a single shot on target.

    extension ViewController: ErrorShooting {
    
        func shoot(error: RetriableError, attempt: Int, complete: @escaping (Shot) -> Void) {
            let alert = UIAlertController(title: "", message: "Something wrong happened", preferredStyle: .alert)
            if error.canRetry && attempt < 3 {
                alert.addAction(
                    UIAlertAction(title: "Retry", style: .cancel) { _ in
                        complete(.miss)
                    }
                )
            }
            alert.addAction(
                UIAlertAction(title: "Rethrow", style: .destructive) { _ in
                    complete(.hit(error))
                }
            )
            alert.addAction(
                UIAlertAction(title: "Close", style: .default) { _ in
                    complete(.sink)
                }
            )
    
            present(alert, animated: true)
        }
    
    }

Take note that shoot function is generic so another error type can be used.

    class ConsoleErrorLogger: ErrorShooting {
    
        public let level: Level
    
        public init(level: Level) {
            self.level = level
        }
    
        public func shoot(error: DescribableError, attempt: Int, complete: ((Shot) -> Void)) {
            if let message = error.message(for: level) {
                print("Error Log: \(message)")
            }
            complete(.hit(error))
        }
    
    }

After that you can use your instance as a shooter for reactive operator.

    observableThatErrorsOut
        .shootError(with: viewController)
        .shootError(with: ConsoleErrorLogger(level: .debug))

Another example with custom shooter function:

    observableThatErrorsOut
    	.shootError { error, _ in
            print("Sinking an error: \(error.localizedDescription)")
            return .just(.sink)
        }