Refactor progress report on Clean Command (#151)

* Remove unused method

* Fix typo in folder

* Add foldMTap to IO

* Create protocol to report progress

* Create description for events in Clean command

* Create implementation for protocol to report progress

* Remove unnecessary extension

* Update clean dependencies

* Update API to receive new dependencies

* Include new reporting of events in clean command

* Adapt command to report progress

* Add new cases to progress report

* Report finalization at the end of command

* Finish command

* Re-indent

* Move decoration to console implementation

Author: truizlop

project/Component/NefClean/Clean.swift

@@ -11,10 +11,15 @@ public struct Clean {
 
     public func nefPlayground(_ nefPlayground: NefPlaygroundURL) -> EnvIO<CleanEnvironment, CleanError, Void> {
         EnvIO { (env: CleanEnvironment) in
-            binding(
-                |<-env.console.print(information: "\t• Clean playground '\(nefPlayground.name)'"),
+            let step = CleanEvent.cleaningPlayground(nefPlayground.name)
+            return binding(
+                |<-env.progressReport.inProgress(step),
                 |<-env.shell.clean(playground: nefPlayground).provide(env.fileSystem).mapError { e in .clean(info: e) },
-            yield: ())^.reportStatus(console: env.console)
+            yield: ())^
+                .foldMTap(
+                    { e in env.progressReport.failed(step, e) },
+                    { env.progressReport.succeeded(step) })
+                
         }
     }
 }

project/Component/NefClean/Models/CleanEnvironment.swift

@@ -5,12 +5,12 @@ import NefCommon
 import NefModels
 
 public struct CleanEnvironment {
-    public let console: Console
+    public let progressReport: ProgressReport
     public let fileSystem: FileSystem
     public let shell: NefPlaygroundSystem
 
-    public init(console: Console, fileSystem: FileSystem, shell: NefPlaygroundSystem) {
-        self.console = console
+    public init(progressReport: ProgressReport, fileSystem: FileSystem, shell: NefPlaygroundSystem) {
+        self.progressReport = progressReport
         self.fileSystem = fileSystem
         self.shell = shell
     }

project/Component/NefClean/Models/CleanEvent.swift

@@ -0,0 +1,14 @@
+import NefModels
+
+public enum CleanEvent {
+    case cleaningPlayground(String)
+}
+
+extension CleanEvent: CustomProgressDescription {
+    public var progressDescription: String {
+        switch self {
+        case let .cleaningPlayground(name):
+            return "\t• Cleaning playground '\(name)'..."
+        }
+    }
+}

project/Component/NefClean/Utils/IO+Console.swift

@@ -0,0 +1,10 @@
+import BowEffects
+
+public extension IO {
+    func foldMTap<B>(_ f: @escaping (E) -> IO<E, B>,
+                     _ g: @escaping (A) -> IO<E, B>) -> IO<E, A> {
+        handleErrorWith { e in
+            f(e).followedBy(.raiseError(e))
+        }.flatTap(g)^
+    }
+}

project/Component/NefCommon/Utils/IO+Extensions.swift

@@ -30,13 +30,6 @@ public struct Step {
 extension Step {
     /// Defined dummy `Step`
     public static var empty: Step { .init(total: 0, partial: 0, duration: .never) }
-    
-    /// Advance the step a number of increments.
-    /// - Parameter partial: Number of increments for the step.
-    /// - Returns: A `Step` with the current operation advanced.
-    public func increment(_ partial: UInt) -> Step {
-        .init(total: total, partial: self.partial + partial, duration: estimatedDuration)
-    }
 }
 
 /// Describes a `Console` to represent progress information.

project/Component/NefCompiler/Algrebras/CompilerShell.swift renamed to project/Component/NefCompiler/Algebras/CompilerShell.swift

@@ -0,0 +1,66 @@
+import BowEffects
+
+public protocol ProgressReport {
+    func notify<E: Error, A: CustomProgressDescription>(_ event: ProgressEvent<A>) -> IO<E, Void>
+}
+
+public extension ProgressReport {
+    func oneShot<E: Error, A: CustomProgressDescription>(_ step: A) -> IO<E, Void> {
+        self.notify(
+            ProgressEvent(step: step,
+                          status: .oneShot))
+    }
+    
+    func inProgress<E: Error, A: CustomProgressDescription>(_ step: A) -> IO<E, Void> {
+        self.notify(
+            ProgressEvent(step: step,
+                          status: .inProgress))
+    }
+    
+    func succeeded<E: Error, A: CustomProgressDescription>(_ step: A, info: String = "") -> IO<E, Void> {
+        self.notify(
+            ProgressEvent(step: step,
+                          status: .successful(info: info)))
+    }
+    
+    func failed<E: Error, A: CustomProgressDescription>(_ step: A, _ error: E, info: String = "") -> IO<E, Void> {
+        self.notify(
+            ProgressEvent(step: step,
+                          status: .failed(error, info: info)))
+    }
+    
+    func finished<E: Error, A: CustomProgressDescription>(successfully step: A) -> IO<E, Void> {
+        self.notify(
+            ProgressEvent(step: step,
+                          status: .finishedSuccessfully))
+    }
+    
+    func finished<E: Error, A: CustomProgressDescription>(withError step: A) -> IO<E, Void> {
+        self.notify(
+            ProgressEvent(step: step,
+                          status: .finishedWithError))
+    }
+}
+
+public enum ProgressEventStatus {
+    case oneShot
+    case inProgress
+    case successful(info: String)
+    case failed(Error, info: String)
+    case finishedSuccessfully
+    case finishedWithError
+}
+
+public protocol CustomProgressDescription {
+    var progressDescription: String { get }
+}
+
+public struct ProgressEvent<A: CustomProgressDescription> {
+    public let step: A
+    public let status: ProgressEventStatus
+    
+    public init(step: A, status: ProgressEventStatus) {
+        self.step = step
+        self.status = status
+    }
+}

project/Component/NefCompiler/Algrebras/CompilerSystem.swift renamed to project/Component/NefCompiler/Algebras/CompilerSystem.swift

@@ -66,8 +66,8 @@ public protocol CleanAPI {
     ///
     /// - Parameters:
     ///   - nefPlayground: Folder where to search for Xcode Playgrounds - it must be a nef Playground structure.
-    ///   - Returns: An `EnvIO` to perform IO operations that produce errors of type `nef.Error`, having access to an immutable environment of type `Console`.
-    static func clean(nefPlayground: URL) -> EnvIO<Console, nef.Error, Void>
+    ///   - Returns: An `EnvIO` to perform IO operations that produce errors of type `nef.Error`, having access to an immutable environment of type `ProgressReport`.
+    static func clean(nefPlayground: URL) -> EnvIO<ProgressReport, nef.Error, Void>
 }
 
 /// Describes the API for `Markdown`