Skip analysis is both types of duplication disabled

Currently duplication analysis runs regardless of the configuration
settings, which are only checked at the time of issue reporting to
determine whether or not to emit it.

This means that if a configuration has all duplication disabled
(identical and similar code), analysis will still run on all files, and
then ultimately output nothing.

This change completely skips analysis if both types of duplication are
disabled.

Author: Chris Hulton

lib/cc/engine/analyzers/engine_config.rb

@@ -6,7 +6,13 @@ module Analyzers
       class EngineConfig
         DEFAULT_COUNT_THRESHOLD = 2
         IDENTICAL_CODE_CHECK = "identical-code".freeze
+        IDENTICAL_CODE_CHECK_LEGACY_NAME = "Identical code".freeze
         SIMILAR_CODE_CHECK = "similar-code".freeze
+        SIMILAR_CODE_CHECK_LEGACY_NAME = "Similar code".freeze
+        CHECK_MAPPINGS = {
+          IDENTICAL_CODE_CHECK_LEGACY_NAME => IDENTICAL_CODE_CHECK,
+          SIMILAR_CODE_CHECK_LEGACY_NAME => SIMILAR_CODE_CHECK,
+        }.freeze
 
         InvalidConfigError = Class.new(StandardError)
 
@@ -83,12 +89,18 @@ def patterns_for(language, fallbacks)
           Array(fetch_language(language).fetch("patterns", fallbacks))
         end
 
-        def check_enabled?(violation)
-          legacy_config = legacy_checks.fetch(violation.fingerprint_check_name, {
+        def check_enabled?(legacy_check_name, check_name)
+          legacy_config = legacy_checks.fetch(legacy_check_name, {
             "enabled" => true
           })
 
-          qm_checks.fetch(violation.check_name, legacy_config).fetch("enabled", true)
+          qm_checks.fetch(check_name, legacy_config).fetch("enabled", true)
+        end
+
+        def all_checks_disabled?
+          CHECK_MAPPINGS.none? do |legacy_check_name, check_name|
+            check_enabled?(legacy_check_name, check_name)
+          end
         end
 
         private

lib/cc/engine/analyzers/reporter.rb

@@ -163,7 +163,10 @@ def insufficient_occurrence?(violation)
         end
 
         def check_disabled?(violation)
-          !engine_config.check_enabled?(violation)
+          !engine_config.check_enabled?(
+            violation.fingerprint_check_name,
+            violation.check_name,
+          )
         end
       end
     end

lib/cc/engine/duplication.rb

@@ -30,6 +30,8 @@ def initialize(directory:, engine_config:, io:)
       end
 
       def run
+        return if engine_config.all_checks_disabled?
+
         Dir.chdir(directory) do
           languages_to_analyze.each do |language|
             engine = LANGUAGES[language].new(engine_config: engine_config)

spec/cc/engine/analyzers/engine_config_spec.rb

@@ -341,14 +341,14 @@
       engine_config = stub_qm_config(similar: false)
 
       violation = double(check_name: "similar-code", fingerprint_check_name: "Similar code")
-      expect(engine_config.check_enabled?(violation)).to eq(false)
+      expect(engine_config.check_enabled?(violation.fingerprint_check_name, violation.check_name)).to eq(false)
     end
 
     it "returns true for similar-code check when enabled" do
       engine_config = stub_qm_config(similar: true)
 
       violation = double(check_name: "similar-code", fingerprint_check_name: "Similar code")
-      expect(engine_config.check_enabled?(violation)).to eq(true)
+      expect(engine_config.check_enabled?(violation.fingerprint_check_name, violation.check_name)).to eq(true)
     end
 
     it "respects legacy config when present" do
@@ -360,7 +360,7 @@
       )
 
       violation = double(check_name: "similar-code", fingerprint_check_name: "Similar code")
-      expect(engine_config.check_enabled?(violation)).to eq(false)
+      expect(engine_config.check_enabled?(violation.fingerprint_check_name, violation.check_name)).to eq(false)
     end
 
     it "overrides legacy config when both present" do
@@ -372,35 +372,77 @@
       )
 
       violation = double(check_name: "similar-code", fingerprint_check_name: "Similar code")
-      expect(engine_config.check_enabled?(violation)).to eq(false)
+      expect(engine_config.check_enabled?(violation.fingerprint_check_name, violation.check_name)).to eq(false)
     end
 
     it "returns true by default" do
       engine_config = described_class.new({ "config" => {} })
 
       violation = double(check_name: "similar-code", fingerprint_check_name: "Similar code")
-      expect(engine_config.check_enabled?(violation)).to eq(true)
+      expect(engine_config.check_enabled?(violation.fingerprint_check_name, violation.check_name)).to eq(true)
     end
 
     it "returns false for identical-code check when disabled" do
       engine_config = stub_qm_config(identical: false)
 
       violation = double(check_name: "identical-code", fingerprint_check_name: "Identical code")
-      expect(engine_config.check_enabled?(violation)).to eq(false)
+      expect(engine_config.check_enabled?(violation.fingerprint_check_name, violation.check_name)).to eq(false)
     end
 
     it "returns true for identical-code check when enabled" do
       engine_config = stub_qm_config(identical: true)
 
       violation = double(check_name: "identical-code", fingerprint_check_name: "Identical code")
-      expect(engine_config.check_enabled?(violation)).to eq(true)
+      expect(engine_config.check_enabled?(violation.fingerprint_check_name, violation.check_name)).to eq(true)
     end
 
     it "returns true by default" do
       engine_config = described_class.new({ "config" => {} })
 
       violation = double(check_name: "identical-code", fingerprint_check_name: "Identical code")
-      expect(engine_config.check_enabled?(violation)).to eq(true)
+      expect(engine_config.check_enabled?(violation.fingerprint_check_name, violation.check_name)).to eq(true)
+    end
+  end
+
+  describe "#all_checks_disabled?" do
+    context "qm config" do
+      it "returns true if all checks are disabled" do
+        engine_config = stub_qm_config(identical: false, similar: false)
+
+        expect(engine_config.all_checks_disabled?).to eq(true)
+      end
+
+      it "returns false if only one check is disabled" do
+        engine_config = stub_qm_config(identical: false, similar: true)
+
+        expect(engine_config.all_checks_disabled?).to eq(false)
+      end
+
+      it "returns false if no checks are disabled" do
+        engine_config = stub_qm_config(identical: true, similar: true)
+
+        expect(engine_config.all_checks_disabled?).to eq(false)
+      end
+    end
+
+    context "legacy config" do
+      it "returns true if all checks are disabled" do
+        engine_config = stub_legacy_config(identical: false, similar: false)
+
+        expect(engine_config.all_checks_disabled?).to eq(true)
+      end
+
+      it "returns false if only one check is disabled" do
+        engine_config = stub_legacy_config(identical: false, similar: true)
+
+        expect(engine_config.all_checks_disabled?).to eq(false)
+      end
+
+      it "returns false if no checks are disabled" do
+        engine_config = stub_legacy_config(identical: true, similar: true)
+
+        expect(engine_config.all_checks_disabled?).to eq(false)
+      end
     end
   end
 
@@ -418,4 +460,17 @@ def stub_qm_config(similar: true, identical: true)
       },
     })
   end
+
+  def stub_legacy_config(similar: true, identical: true)
+    described_class.new({
+      "checks" => {
+        "Similar code" => {
+          "enabled" => similar,
+        },
+        "Identical code" => {
+          "enabled" => identical,
+        },
+      },
+    })
+  end
 end

spec/cc/engine/duplication_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "cc/engine/duplication"
+
+RSpec.describe(CC::Engine::Duplication) do
+  describe "#run" do
+    it "skips analysis when all duplication checks are disabled" do
+      dir = "foo"
+      config = {
+        "config" => {
+          "checks" => {
+            "similar-code" => {
+              "enabled" => false,
+            },
+            "identical-code" => {
+              "enabled" => false,
+            },
+          },
+        },
+      }
+      expect(Dir).to_not receive(:chdir)
+      expect(CC::Engine::Analyzers::Reporter).to_not receive(:new)
+
+      CC::Engine::Duplication.new(
+        directory: dir, engine_config: config, io: double,
+      ).run
+    end
+  end
+end