Removed collector totals and updated CLI actions

We can delegate to the reporter now that the reporter has all of this information. All CLI actions were updated to reflect these changes including dealing with the loading of commits where applicable since the analyzers won't do this by default anymore.

Milestone: major

Author: bkuhlmann

lib/git/lint/cli/actions/analyze/branch.rb

@@ -15,26 +15,27 @@ class Branch < Sod::Action
 
             on %w[-b --branch]
 
-            def initialize(analyzer: Analyzer.new, **)
+            def initialize(analyzer: Analyzer.new, loader: Git::Lint::Commits::Loader.new, **)
               super(**)
               @analyzer = analyzer
+              @loader = loader
             end
 
             def call(*)
-              parse
+              report
             rescue Errors::Base => error
-              logger.error { error.message }
-              kernel.abort
+              logger.abort error.message
             end
 
             private
 
-            attr_reader :analyzer
+            attr_reader :analyzer, :loader
 
-            def parse
-              analyzer.call do |collector, reporter|
+            def report
+              loader.call.bind do |commits|
+                reporter = analyzer.call commits
                 io.puts reporter
-                kernel.abort if collector.errors?
+                kernel.abort if reporter.errors?
               end
             end
           end

lib/git/lint/cli/actions/analyze/commit.rb

@@ -21,21 +21,25 @@ def initialize(analyzer: Analyzer.new, **)
             end
 
             def call *arguments
-              process arguments.unshift "-1"
+              collect arguments.unshift("-1")
             rescue Errors::Base => error
-              logger.error { error.message }
-              kernel.abort
+              logger.abort error.message
             end
 
             private
 
             attr_reader :analyzer
 
-            def process arguments
-              analyzer.call commits: git.commits(*arguments) do |collector, reporter|
-                io.puts reporter
-                kernel.abort if collector.errors?
-              end
+            def collect arguments
+              git.commits(*arguments).either -> commits { report commits },
+                                             -> message { logger.abort message.chomp }
+            end
+
+            def report commits
+              reporter = analyzer.call commits
+
+              io.puts reporter
+              kernel.abort if reporter.errors?
             end
           end
         end

lib/git/lint/cli/actions/hook.rb

@@ -21,17 +21,17 @@ def initialize(analyzer: Analyzer.new, **)
           end
 
           def call path
-            analyzer.call commits: commits(path) do |collector, reporter|
-              io.puts reporter
-              kernel.abort if collector.errors?
-            end
+            reporter = analyzer.call read(path)
+
+            io.puts reporter
+            kernel.abort if reporter.errors?
           end
 
           private
 
           attr_reader :analyzer
 
-          def commits(path) = git.uncommitted(path).fmap { |commit| [commit] }
+          def read(path) = git.uncommitted(path).bind { |commit| [commit] }
         end
       end
     end

lib/git/lint/collector.rb

@@ -31,20 +31,6 @@ def clear = collection.clear && self
 
       def empty? = collection.empty?
 
-      def warnings? = collection.values.flatten.any?(&:warning?)
-
-      def errors? = collection.values.flatten.any?(&:error?)
-
-      def issues? = collection.values.flatten.any?(&:invalid?)
-
-      def total_warnings = collection.values.flatten.count(&:warning?)
-
-      def total_errors = collection.values.flatten.count(&:error?)
-
-      def total_issues = collection.values.flatten.count(&:invalid?)
-
-      def total_commits = collection.keys.size
-
       def to_h = collection
 
       private

spec/lib/git/lint/cli/actions/analyze/branch_spec.rb

@@ -12,6 +12,8 @@
   include_context "with Git repository"
 
   describe "#call" do
+    before { allow(logger).to receive(:abort) }
+
     it "reports no issues with valid commits" do
       git_repo_dir.change_dir do
         `git switch --quiet --create test`
@@ -50,22 +52,14 @@
       end
     end
 
-    context "with failure" do
-      subject(:action) { described_class.new analyzer: }
-
-      let(:analyzer) { instance_double Git::Lint::Analyzer }
+    it "logs error for failure" do
+      analyzer = instance_double Git::Lint::Analyzer
+      action = described_class.new(analyzer:)
 
-      before { allow(analyzer).to receive(:call).and_raise(Git::Lint::Errors::Base, "Danger!") }
-
-      it "logs error" do
-        action.call
-        expect(logger.reread).to match(/🛑.+Danger!/)
-      end
+      allow(analyzer).to receive(:call).and_raise(Git::Lint::Errors::Base, "Danger!")
+      action.call
 
-      it "aborts" do
-        action.call
-        expect(kernel).to have_received(:abort)
-      end
+      expect(logger).to have_received(:abort).with("Danger!")
     end
   end
 end

spec/lib/git/lint/cli/actions/analyze/commit_spec.rb

@@ -12,12 +12,14 @@
   include_context "with Git repository"
 
   describe "#call" do
+    before { allow(logger).to receive(:abort) }
+
     it "reports zero issues with valid SHA" do
       git_repo_dir.change_dir do
         `git switch --quiet --create test`
         `touch b.txt && git add . && git commit --no-verify --message "Added A" --message "Test."`
 
-        action.call "-1"
+        action.call
 
         expect(io.reread).to match(/.+1 commit inspected.*0 issues.+detected/m)
       end
@@ -28,7 +30,7 @@
         `git switch --quiet --create test`
         `touch a.txt && git add . && git commit --no-verify --message "Add A"`
 
-        action.call "-1"
+        action.call
 
         expect(io.reread).to match(
           /Commit Subject Prefix Error.+1 commit inspected.*1 issue.+detected/m
@@ -37,11 +39,16 @@
     end
 
     it "reports zero issues when given no SHAs" do
+      allow(logger).to receive(:abort)
+
       git_repo_dir.change_dir do
         `rm -rf .git && git init`
         action.call
-        expect(io.reread).to match(/.+0 commits inspected.*0 issues.+detected/m)
       end
+
+      expect(logger).to have_received(:abort).with(
+        "fatal: your current branch 'main' does not have any commits yet"
+      )
     end
 
     it "aborts with invalid SHA" do
@@ -56,22 +63,14 @@
       end
     end
 
-    context "with failure" do
-      subject(:action) { described_class.new analyzer: }
-
-      let(:analyzer) { instance_double Git::Lint::Analyzer }
+    it "logs error for failure" do
+      analyzer = instance_double Git::Lint::Analyzer
+      action = described_class.new(analyzer:)
 
-      before { allow(analyzer).to receive(:call).and_raise(Git::Lint::Errors::Base, "Danger!") }
+      allow(analyzer).to receive(:call).and_raise(Git::Lint::Errors::Base, "Danger!")
+      action.call
 
-      it "logs error" do
-        action.call
-        expect(logger.reread).to match(/🛑.+Danger!/)
-      end
-
-      it "aborts" do
-        action.call
-        expect(kernel).to have_received(:abort)
-      end
+      expect(logger).to have_received(:abort).with "Danger!"
     end
   end
 end

spec/lib/git/lint/cli/actions/hook_spec.rb

@@ -26,7 +26,7 @@
       end
     end
 
-    it "aborts with errors" do
+    it "aborts with invalid commit" do
       git_repo_dir.change_dir do
         action.call SPEC_ROOT.join("support/fixtures/commit-invalid.txt")
         expect(kernel).to have_received(:abort)

spec/lib/git/lint/collector_spec.rb

@@ -113,113 +113,6 @@
     end
   end
 
-  describe "#warnings?" do
-    it "answers true with invalid analyzers at warn severity" do
-      collector.add valid_analyzer
-      collector.add warn_analyzer
-      collector.add error_analyzer
-
-      expect(collector.warnings?).to be(true)
-    end
-
-    it "answers false with no invalid analyzers at warn severity" do
-      collector.add valid_analyzer
-      collector.add error_analyzer
-
-      expect(collector.warnings?).to be(false)
-    end
-  end
-
-  describe "#errors?" do
-    it "answers true with invalid analyzers at error severity" do
-      collector.add valid_analyzer
-      collector.add warn_analyzer
-      collector.add error_analyzer
-
-      expect(collector.errors?).to be(true)
-    end
-
-    it "answers false with no invalid analyzers at error severity" do
-      collector.add valid_analyzer
-      collector.add warn_analyzer
-
-      expect(collector.errors?).to be(false)
-    end
-  end
-
-  describe "#issues?" do
-    it "answers true with invalid analyzers" do
-      collector.add valid_analyzer
-      collector.add warn_analyzer
-      collector.add error_analyzer
-
-      expect(collector.issues?).to be(true)
-    end
-
-    it "answers false with valid analyzers" do
-      collector.add valid_analyzer
-      expect(collector.issues?).to be(false)
-    end
-  end
-
-  describe "#total_warnings" do
-    it "answers total warnings when invalid analyzers with warnings exist" do
-      collector.add warn_analyzer
-      expect(collector.total_warnings).to eq(1)
-    end
-
-    it "answers zero warnings when analyzers without warnings exist" do
-      collector.add valid_analyzer
-      collector.add error_analyzer
-
-      expect(collector.total_warnings).to eq(0)
-    end
-  end
-
-  describe "#total_errors" do
-    it "answers total errors when invalid analyzers with errors exist" do
-      collector.add error_analyzer
-      expect(collector.total_errors).to eq(1)
-    end
-
-    it "answers zero errors when analyzers without errors exist" do
-      collector.add valid_analyzer
-      collector.add warn_analyzer
-
-      expect(collector.total_errors).to eq(0)
-    end
-  end
-
-  describe "#total_issues" do
-    it "answers total issues when invalid analyzers exist" do
-      collector.add valid_analyzer
-      collector.add warn_analyzer
-      collector.add error_analyzer
-
-      expect(collector.total_issues).to eq(2)
-    end
-
-    it "answers zero issues when valid analyzers exist" do
-      collector.add valid_analyzer
-      expect(collector.total_issues).to eq(0)
-    end
-
-    it "answers zero issues when no analyzers exist" do
-      expect(collector.total_issues).to eq(0)
-    end
-  end
-
-  describe "#total_commits" do
-    it "answers total commits" do
-      collector.add valid_analyzer
-      expect(collector.total_commits).to eq(1)
-    end
-
-    it "answers zero with no commits" do
-      expect(collector.total_commits).to eq(0)
-    end
-  end
-
   describe "#to_h" do
     it "answers hash of commit and analyzers" do
       collector.add valid_analyzer