Use individual check thresholds to filter results

Previous commits enabled config to pick up this config appropiately.
This commit adjusts the reporter pipeline to filter out reported
violations that don't meet the mass threshold.

Flay just takes on threshold in its config, so we calculate the
minimumt threshold of both checks & give that to Flay, then filter the
results afterwords based on check type.

Author: wfleming

lib/cc/engine/analyzers/analyzer_base.rb

@@ -58,6 +58,10 @@ def language
           self.class::LANGUAGE
         end
 
+        def check_mass_threshold(check)
+          engine_config.mass_threshold_for(language, check) || self.class::DEFAULT_MASS_THRESHOLD
+        end
+
         def mass_threshold
           engine_config.minimum_mass_threshold_for(language) || self.class::DEFAULT_MASS_THRESHOLD
         end
@@ -66,8 +70,8 @@ def count_threshold
           engine_config.count_threshold_for(language)
         end
 
-        def calculate_points(mass)
-          overage = mass - mass_threshold
+        def calculate_points(violation)
+          overage = violation.mass - check_mass_threshold(violation.inner_check_name)
           base_points + (overage * points_per_overage)
         end
 

lib/cc/engine/analyzers/reporter.rb

@@ -136,7 +136,13 @@ def flay_options
         end
 
         def skip?(violation)
-          insufficient_occurrence?(violation) || check_disabled?(violation)
+          below_threshold?(violation) ||
+            insufficient_occurrence?(violation) ||
+            check_disabled?(violation)
+        end
+
+        def below_threshold?(violation)
+          violation.mass < language_strategy.check_mass_threshold(violation.inner_check_name)
         end
 
         def insufficient_occurrence?(violation)

lib/cc/engine/analyzers/violation.rb

@@ -50,6 +50,14 @@ def identical?
           @identical
         end
 
+        def inner_check_name
+          if identical?
+            EngineConfig::IDENTICAL_CODE_CHECK
+          else
+            EngineConfig::SIMILAR_CODE_CHECK
+          end
+        end
+
         private
 
         attr_reader :language_strategy, :other_sexps, :current_sexp
@@ -59,7 +67,7 @@ def check_name
         end
 
         def calculate_points
-          @calculate_points ||= language_strategy.calculate_points(mass)
+          @calculate_points ||= language_strategy.calculate_points(self)
         end
 
         def points_across_occurrences

spec/cc/engine/analyzers/ruby/main_spec.rb

@@ -186,9 +186,49 @@ def self.from_remediation_amount(amount)
 
         expect(issues.length).to eq(0)
       end
+
+      it "respects the per-check mass thresholds" do
+        create_source_file("foo.rb", <<-EORUBY)
+          def identical
+            puts "identical \#{thing.bar} \#{other.fun} \#{moo ? "moo" : "cluck"}"
+            puts "identical \#{thing.bar} \#{other.fun} \#{moo ? "moo" : "cluck"}"
+            puts "identical \#{thing.bar} \#{other.fun} \#{moo ? "moo" : "cluck"}"
+          end
+          describe 'similar1' do
+            before { subject.type = 'js' }
+            it 'returns true' do
+              expect(subject.ruby?).to be true
+            end
+          end
+          describe 'similar2' do
+            before { subject.type = 'js' }
+            it 'returns true' do
+              expect(subject.js?).to be true
+            end
+          end
+        EORUBY
+
+        config = CC::Engine::Analyzers::EngineConfig.new({
+          "config" => {
+            "languages" => %w[ruby],
+            "checks" => {
+              "identical-code" => { "config" => { "threshold" => 5 } },
+              "similar-code" => { "config" => { "threshold" => 20 } },
+            },
+          },
+        })
+        output = run_engine(config).strip.split("\0").first.strip
+        json = JSON.parse(output)
+
+        expect(json["check_name"]).to eq "Identical code"
+        expect(json["location"]).to eq({
+          "path" => "foo.rb",
+          "lines" => { "begin" => 2, "end" => 2 },
+        })
+      end
     end
 
-    describe "#calculate_points(mass)" do
+    describe "#calculate_points" do
       let(:analyzer) { Ruby::Main.new(engine_config: engine_conf) }
       let(:base_points) { Ruby::Main::BASE_POINTS }
       let(:points_per) { Ruby::Main::POINTS_PER_OVERAGE }
@@ -198,9 +238,10 @@ def self.from_remediation_amount(amount)
         it "calculates mass overage points" do
           mass = threshold + 10
           overage = mass - threshold
+          violation = OpenStruct.new(mass: mass, inner_check_name: "identical-code")
 
           expected_points = base_points + overage * points_per
-          points = analyzer.calculate_points(mass)
+          points = analyzer.calculate_points(violation)
 
           expect(points).to eq(expected_points)
         end
@@ -210,9 +251,10 @@ def self.from_remediation_amount(amount)
         it "calculates mass overage points" do
           mass = threshold - 5
           overage = mass - threshold
+          violation = OpenStruct.new(mass: mass, inner_check_name: "identical-code")
 
           expected_points = base_points + overage * points_per
-          points = analyzer.calculate_points(mass)
+          points = analyzer.calculate_points(violation)
 
           expect(points).to eq(expected_points)
         end
@@ -222,9 +264,10 @@ def self.from_remediation_amount(amount)
         it "calculates mass overage points" do
           mass = threshold
           overage = mass - threshold
+          violation = OpenStruct.new(mass: mass, inner_check_name: "identical-code")
 
           expected_points = base_points + overage * points_per
-          points = analyzer.calculate_points(mass)
+          points = analyzer.calculate_points(violation)
 
           expect(points).to eq(expected_points)
         end