Refactor lib / cli reporting to use events

Author: cap10morgan

cljfmt/src/cljfmt/tool.clj

@@ -115,53 +115,59 @@
             (and file diff) (assoc-in [:incorrect path] diff)
             (and file exception) (assoc-in [:error path] exception))))
 
-(defmulti check-report-file (fn [& args] (first args)))
-(defmulti check-report-final (fn [& args] (first args)))
+(defmulti report-cli (fn [event & _] event))
+(defmulti report-lib (fn [event & _] event))
 
-(defmethod check-report-file :cli
-  [_ options status]
-  (print-file-status options status)
-  (:counts status))
+(defmethod report-cli :check/initial
+  [_ _ _]
+  nil)
 
-(defmethod check-report-final :cli
-  [_ results]
-  (let [counts (reduce merge-counts results)]
+(defmethod report-cli :check/file
+  [_ context data]
+  (print-file-status context data)
+  (:counts data))
+
+(defmethod report-cli :check/summary
+  [_ summary _]
+  (let [counts (reduce merge-counts summary)]
     (print-final-count counts)
     (exit counts)))
 
-(defmethod check-report-file :lib
-  [_ _ status]
-  status)
+(defmethod report-lib :check/initial
+  [_ _ _]
+  nil)
+
+(defmethod report-lib :check/file
+  [_ _ data]
+  data)
 
-(defmethod check-report-final :lib
-  [_ results]
-  (reduce merge-statuses {} results))
+(defmethod report-lib :check/summary
+  [_ context _]
+  (reduce merge-statuses {} context))
 
 (defn check-no-config
   "The same as `check`, but ignores dotfile configuration."
-  [{:keys [parallel? paths report/file report/final] :as options}]
-  (let [map*        (if parallel? pmap map)
-        report-file (partial file options)
-        results     (->> paths
-                         (mapcat (partial find-files options))
-                         (map* (partial check-one options))
-                         (map report-file))]
-    (final results)))
+  [{:keys [parallel? paths report] :as options}]
+  (report :check/initial options nil)
+  (let [map*    (if parallel? pmap map)
+        summary (->> paths
+                     (mapcat (partial find-files options))
+                     (map* (partial check-one options))
+                     (reduce #(report :check/file %1 %2) options))]
+    (report :check/summary summary nil)))
 
 (defn check
   "Checks that the Clojure paths specified by the :paths option are
   correctly formatted."
   [options]
-  (let [opts (merge {:report/file  #(check-report-file :cli %1 %2)
-                     :report/final #(check-report-final :cli %)}
+  (let [opts (merge {:report report-cli}
                     (config/load-config) options)]
     (check-no-config opts)))
 
 (defn check-paths
   "Runs a check on the provided paths and returns a map detailing the results."
   [paths & [options]]
-  (let [opts (merge {:report/file  #(check-report-file :lib %1 %2)
-                     :report/final #(check-report-final :lib %)}
+  (let [opts (merge {:report report-lib}
                     (config/load-config) options
                     {:paths paths})]
     (check-no-config opts)))
@@ -182,38 +188,52 @@
 (defn- recursively-find-files [{:keys [paths] :as options}]
   (mapcat #(find-files options %) (set paths)))
 
-(defmulti fix-report (fn [& args] (first args)))
+(defmethod report-cli :fix/initial
+  [_ _ _]
+  nil)
+
+(defmethod report-cli :fix/file
+  [_ context data]
+  (print-file-status context data))
+
+(defmethod report-cli :fix/summary
+  [_ _ _]
+  nil)
+
+(defmethod report-lib :fix/initial
+  [_ _ _]
+  nil)
 
-(defmethod fix-report :cli
-  [_ options status]
-  (print-file-status options status))
+(defmethod report-lib :fix/file
+  [_ _ data]
+  data)
 
-(defmethod fix-report :lib
-  [_ _ status]
-  status)
+(defmethod report-lib :fix/summary
+  [_ summary _]
+  summary)
 
 (defn fix-no-config
   "The same as `fix`, but ignores dotfile configuration."
-  [{:keys [parallel? report/fix] :as options}]
-  (let [files (recursively-find-files options)
-        map*  (if parallel? pmap map)
-        fix-report (partial fix options)]
-    (->> files
-         (map* (partial fix-one options))
-         (map fix-report)
-         dorun)))
+  [{:keys [parallel? report] :as options}]
+  (report :fix/initial options nil)
+  (let [files   (recursively-find-files options)
+        map*    (if parallel? pmap map)
+        summary (->> files
+                     (map* (partial fix-one options))
+                     (reduce #(report :fix/file %1 %2) options))]
+    (report :fix/summary summary nil)))
 
 (defn fix
   "Fixes the formatting for all files specified by the :paths option."
   [options]
-  (let [opts (merge {:report/fix #(fix-report :cli %1 %2)}
+  (let [opts (merge {:report report-cli}
                     (config/load-config) options)]
     (fix-no-config opts)))
 
 (defn fix-paths
   "Fixes code in the provided paths."
   [paths & [options]]
-  (let [opts (merge {:report/fix #(fix-report :lib %1 %2)}
+  (let [opts (merge {:report report-lib}
                     (config/load-config) options
                     {:paths paths})]
     (fix-no-config opts)))