Tune RUBY remediation points to match Classic

Changes include:
- Refactor `calculate_points` method to be purview of language,
not `Violation` - to permit independent calculation formulas
- Increase ruby `BASE_POINTS`
- Change calculation formula from
    - `base_points * issue.mass_threshold`
  to
   - `base_points + overage * points_per`

Rubric in classic for Ruby:
https://github.com/codeclimate/analyzer/blob/master/lib/quality/rubric.rb#L12c

Updates for other languages to come post additional language-specific tuning

Author: ABaldwinHunter

lib/cc/engine/analyzers/analyzer_base.rb

@@ -35,8 +35,8 @@ def mass_threshold
           engine_config.mass_threshold_for(self.class::LANGUAGE) || self.class::DEFAULT_MASS_THRESHOLD
         end
 
-        def base_points
-          self.class::BASE_POINTS
+        def calculate_points(issue)
+          self.class::BASE_POINTS * issue.mass
         end
 
         private

lib/cc/engine/analyzers/reporter.rb

@@ -60,19 +60,15 @@ def flay
 
         attr_reader :engine_config, :language_strategy, :io
 
-        def mass_threshold
-          @mass_threshold ||= language_strategy.mass_threshold
-        end
-
         def new_violation(issue)
           hashes = flay.hashes[issue.structural_hash]
-          Violation.new(language_strategy.base_points, issue, hashes)
+          Violation.new(language_strategy, issue, hashes)
         end
 
         def flay_options
           {
             diff: false,
-            mass: mass_threshold,
+            mass: language_strategy.mass_threshold,
             summary: false,
             verbose: false,
             number: true,

lib/cc/engine/analyzers/ruby/main.rb

@@ -18,11 +18,20 @@ class Main < CC::Engine::Analyzers::Base
 
           ]
           DEFAULT_MASS_THRESHOLD = 18
-          BASE_POINTS = 10_000
+          BASE_POINTS = 1_500_000
+          POINTS_PER_OVERAGE = 100_000
           TIMEOUT = 300
 
+          def calculate_points(issue)
+            BASE_POINTS + (overage(issue) * POINTS_PER_OVERAGE)
+          end
+
           private
 
+          def overage(issue)
+            issue.mass - mass_threshold
+          end
+
           def process_file(file)
             RubyParser.new.process(File.binread(file), file, TIMEOUT)
           end

lib/cc/engine/analyzers/violation.rb

@@ -8,8 +8,8 @@ module Analyzers
       class Violation
         attr_reader :issue
 
-        def initialize(base_points, issue, hashes)
-          @base_points = base_points
+        def initialize(language, issue, hashes)
+          @language = language
           @issue = issue
           @hashes = hashes
         end
@@ -34,7 +34,7 @@ def report_name
 
         private
 
-        attr_reader :base_points, :hashes
+        attr_reader :language, :hashes
 
         def current_sexp
           @location ||= sorted_hashes.first
@@ -57,7 +57,7 @@ def name
         end
 
         def calculate_points
-          base_points * issue.mass
+          language.calculate_points(issue)
         end
 
         def format_location

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

@@ -38,7 +38,7 @@
         "path" => "foo.rb",
         "lines" => { "begin" => 1, "end" => 5 },
       })
-      expect(json["remediation_points"]).to eq(360000)
+      expect(json["remediation_points"]).to eq(3300000)
       expect(json["other_locations"]).to eq([
         {"path" => "foo.rb", "lines" => { "begin" => 9, "end" => 13} },
       ])
@@ -57,6 +57,49 @@
     end
   end
 
+  describe "#calculate_points(issue)" do
+    let(:ruby) { CC::Engine::Analyzers::Ruby::Main.new(engine_config: engine_conf) }
+    let(:base_points) { CC::Engine::Analyzers::Ruby::Main::BASE_POINTS }
+    let(:points_per) { CC::Engine::Analyzers::Ruby::Main::POINTS_PER_OVERAGE }
+    let(:threshold) { CC::Engine::Analyzers::Ruby::Main::DEFAULT_MASS_THRESHOLD }
+
+    context "when issue mass exceeds threshold" do
+      it "calculates mass overage points" do
+        issue = double(:issue, mass: threshold + 10)
+        overage = issue.mass - threshold
+
+        expected_points = base_points + overage * points_per
+        points = ruby.calculate_points(issue)
+
+        expect(points).to eq(expected_points)
+      end
+    end
+
+    context "when issue mass is less than threshold" do
+      it "calculates mass overage points" do
+        issue = double(:issue, mass: threshold - 5)
+        overage = issue.mass - threshold
+
+        expected_points = base_points + overage * points_per
+        points = ruby.calculate_points(issue)
+
+        expect(points).to eq(expected_points)
+      end
+    end
+
+    context "when issue mass equals threshold" do
+      it "calculates mass overage points" do
+        issue = double(:issue, mass: threshold)
+        overage = issue.mass - threshold
+
+        expected_points = base_points + overage * points_per
+        points = ruby.calculate_points(issue)
+
+        expect(points).to eq(expected_points)
+      end
+    end
+  end
+
   def engine_conf
     CC::Engine::Analyzers::EngineConfig.new({})
   end