feature_map 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da72179134e412ae870b9e28e3642fce5968f893d43a1ccf6bdf9ebb0c4f955c
-  data.tar.gz: '0825071345a6e6589dcd331f01f5fb1f31c20824f3dadef6fd28330e686499f6'
+  metadata.gz: b56fb3fcd3da34a3f15aa1a15714c37287c2dc9117ceb02a5df849ba076e9376
+  data.tar.gz: 644e0c180a214481117b8d612f6dc400ae8a5eda7bbe171061f03bc1ddb73a95
 SHA512:
-  metadata.gz: 8e723bc85047a19677f535ee7f569454101618f76a677338ae2f78a9eb5114726713d46a85a0b1bd7ba87a020d629d373e7b8e9b0d5b34566d607d2594a05058
-  data.tar.gz: 558061825589dc8a45d6a61c6a59843dbf9a657ef7b5484704f036d950aaf7219fc71cd5e4ec403735e9eaa5a9865169932c441f1e0ff29ada1ee0e210c9a3a3
+  metadata.gz: b900d2781d2374618d966655f0292cb0568e1b707a1c38b41a80d8396bd31b0e95663371b6471391bd7680f6782762f1dfeb0f05c7752fcd2b25f927dd0b1795
+  data.tar.gz: 5d47dd3e2f2250d84cfc05ccc6944c85ca390530ce3fb147569dfabe9c83cd526ee8cbb74c3ef17716a29c9f1968b9cc5d9a58fd99715b5eb7aa25df59e242cb

data/README.md

@@ -33,7 +33,6 @@ Contributions are welcome and appreciated. Here's how to get started:
 - install dependencies: `$ bundle install`
 - run tests: `$ bundle exec rspec`
 - run Rubocop: `$ bundle exec rubocop`
-- run Sorbet: `$ bundle exec srb tc`
 
 That's it! Assuming you can complete all of these steps without any error or issues, you should be good to go.
 

data/bin/featuremap

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-# typed: strict
 
 require 'feature_map'
 FeatureMap::Cli.run!(ARGV)

data/lib/feature_map/cli.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 require 'optparse'
 require 'pathname'
 require 'fileutils'

data/lib/feature_map/code_features/plugin.rb

@@ -1,56 +1,39 @@
-# typed: strict
-
 module FeatureMap
   module CodeFeatures
     # Plugins allow a client to add validation on custom keys in the feature YML.
     # For now, only a single plugin is allowed to manage validation on a top-level key.
     # In the future we can think of allowing plugins to be gracefully merged with each other.
     class Plugin
-      extend T::Helpers
-      extend T::Sig
-
-      abstract!
-
-      sig { params(feature: Feature).void }
       def initialize(feature)
         @feature = feature
       end
 
-      sig { params(base: T.untyped).void }
       def self.inherited(base) # rubocop:disable Lint/MissingSuper
-        all_plugins << T.cast(base, T.class_of(Plugin))
+        all_plugins << base
       end
 
-      sig { returns(T::Array[T.class_of(Plugin)]) }
       def self.all_plugins
-        @all_plugins ||= T.let(@all_plugins, T.nilable(T::Array[T.class_of(Plugin)]))
         @all_plugins ||= []
         @all_plugins
       end
 
-      sig { params(features: T::Array[Feature]).returns(T::Array[String]) }
       def self.validation_errors(features)
         []
       end
 
-      sig { params(feature: Feature).returns(T.attached_class) }
       def self.for(feature)
         register_feature(feature)
       end
 
-      sig { params(feature: Feature, key: String).returns(String) }
       def self.missing_key_error_message(feature, key)
         "#{feature.name} is missing required key `#{key}`"
       end
 
-      sig { returns(T::Hash[T.nilable(String), T::Hash[T.class_of(Plugin), Plugin]]) }
       def self.registry
-        @registry ||= T.let(@registry, T.nilable(T::Hash[String, T::Hash[T.class_of(Plugin), Plugin]]))
         @registry ||= {}
         @registry
       end
 
-      sig { params(feature: Feature).returns(T.attached_class) }
       def self.register_feature(feature)
         # We pull from the hash since `feature.name` uses the registry
         feature_name = feature.raw_hash['name']
@@ -59,15 +42,13 @@ module FeatureMap
         registry_for_feature = registry[feature_name] || {}
         registry[feature_name] ||= {}
         registry_for_feature[self] ||= new(feature)
-        T.unsafe(registry_for_feature[self])
+        registry_for_feature[self]
       end
 
-      sig { void }
       def self.bust_caches!
         all_plugins.each(&:clear_feature_registry!)
       end
 
-      sig { void }
       def self.clear_feature_registry!
         @registry = nil
       end

data/lib/feature_map/code_features/plugins/identity.rb

@@ -1,24 +1,17 @@
-# typed: true
-
 module FeatureMap
   module CodeFeatures
     module Plugins
       class Identity < Plugin
-        extend T::Sig
-        extend T::Helpers
-
         IdentityStruct = Struct.new(:name)
 
-        sig { returns(IdentityStruct) }
         def identity
           IdentityStruct.new(
             @feature.raw_hash['name']
           )
         end
 
-        sig { override.params(features: T::Array[CodeFeatures::Feature]).returns(T::Array[String]) }
         def self.validation_errors(features)
-          errors = T.let([], T::Array[String])
+          errors = []
 
           uniq_set = Set.new
           features.each do |feature|

data/lib/feature_map/code_features.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# typed: strict
-
 require 'yaml'
 require 'csv'
 require 'set'
@@ -11,22 +9,16 @@ require 'feature_map/code_features/plugins/identity'
 
 module FeatureMap
   module CodeFeatures
-    extend T::Sig
-
-    NON_BREAKING_SPACE = T.let(65_279.chr(Encoding::UTF_8), String)
+    NON_BREAKING_SPACE = 65_279.chr(Encoding::UTF_8)
 
     class IncorrectPublicApiUsageError < StandardError; end
 
-    sig { returns(T::Array[Feature]) }
     def self.all
-      @all = T.let(@all, T.nilable(T::Array[Feature]))
       @all ||= from_csv('.feature_map/feature_definitions.csv')
       @all ||= for_directory('.feature_map/definitions')
     end
 
-    sig { params(name: String).returns(T.nilable(Feature)) }
     def self.find(name)
-      @index_by_name = T.let(@index_by_name, T.nilable(T::Hash[String, CodeFeatures::Feature]))
       @index_by_name ||= begin
         result = {}
         all.each { |t| result[t.name] = t }
@@ -36,7 +28,6 @@ module FeatureMap
       @index_by_name[name]
     end
 
-    sig { params(file_path: String).returns(T.nilable(T::Array[Feature])) }
     def self.from_csv(file_path)
       return nil if !File.exist?(file_path)
 
@@ -53,7 +44,6 @@ module FeatureMap
       end
     end
 
-    sig { params(dir: String).returns(T::Array[Feature]) }
     def self.for_directory(dir)
       Pathname.new(dir).glob('**/*.yml').map do |path|
         Feature.from_yml(path.to_s)
@@ -62,14 +52,12 @@ module FeatureMap
       end
     end
 
-    sig { params(features: T::Array[Feature]).returns(T::Array[String]) }
     def self.validation_errors(features)
       Plugin.all_plugins.flat_map do |plugin|
         plugin.validation_errors(features)
       end
     end
 
-    sig { params(string: String).returns(String) }
     def self.tag_value_for(string)
       string.tr('&', ' ').gsub(/\s+/, '_').downcase
     end
@@ -77,7 +65,6 @@ module FeatureMap
     # Generally, you should not ever need to do this, because once your ruby process loads, cached content should not change.
     # Namely, the YML files that are the source of truth for features should not change, so we should not need to look at the YMLs again to verify.
     # The primary reason this is helpful is for tests where each context is testing against a different set of features
-    sig { void }
     def self.bust_caches!
       Plugin.bust_caches!
       @all = nil
@@ -85,9 +72,6 @@ module FeatureMap
     end
 
     class Feature
-      extend T::Sig
-
-      sig { params(config_yml: String).returns(Feature) }
       def self.from_yml(config_yml)
         hash = YAML.load_file(config_yml)
 
@@ -97,7 +81,6 @@ module FeatureMap
         )
       end
 
-      sig { params(raw_hash: T::Hash[T.untyped, T.untyped]).returns(Feature) }
       def self.from_hash(raw_hash)
         new(
           config_yml: nil,
@@ -105,34 +88,22 @@ module FeatureMap
         )
       end
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
       attr_reader :raw_hash
-
-      sig { returns(T.nilable(String)) }
       attr_reader :config_yml
 
-      sig do
-        params(
-          config_yml: T.nilable(String),
-          raw_hash: T::Hash[T.untyped, T.untyped]
-        ).void
-      end
       def initialize(config_yml:, raw_hash:)
         @config_yml = config_yml
         @raw_hash = raw_hash
       end
 
-      sig { returns(String) }
       def name
         Plugins::Identity.for(self).identity.name
       end
 
-      sig { returns(String) }
       def to_tag
         CodeFeatures.tag_value_for(name)
       end
 
-      sig { params(other: Object).returns(T::Boolean) }
       def ==(other)
         if other.is_a?(CodeFeatures::Feature)
           name == other.name
@@ -143,7 +114,6 @@ module FeatureMap
 
       alias eql? ==
 
-      sig { returns(Integer) }
       def hash
         name.hash
       end

data/lib/feature_map/commit.rb

@@ -1,29 +1,10 @@
-# typed: strict
-
 module FeatureMap
   class Commit
-    extend T::Sig
-
-    sig { returns(T.nilable(String)) }
     attr_reader :sha
-
-    sig { returns(T.nilable(String)) }
     attr_reader :description
-
-    sig { returns(T.nilable(String)) }
     attr_reader :pull_request_number
-
-    sig { returns(T::Array[String]) }
     attr_reader :files
 
-    sig do
-      params(
-        sha: T.nilable(String),
-        description: T.nilable(String),
-        pull_request_number: T.nilable(String),
-        files: T::Array[String]
-      ).void
-    end
     def initialize(sha: nil, description: nil, pull_request_number: nil, files: [])
       @sha = sha
       @description = description

data/lib/feature_map/configuration.rb

@@ -1,23 +1,46 @@
-# typed: strict
-
 module FeatureMap
-  class Configuration < T::Struct
-    extend T::Sig
+  class Configuration
+    attr_reader :assigned_globs
+    attr_reader :unassigned_globs
+    attr_reader :unbuilt_gems_path
+    attr_reader :skip_features_validation
+    attr_reader :raw_hash
+    attr_reader :skip_code_ownership
+    attr_reader :require_assignment_for_teams
+    attr_reader :ignore_feature_definitions
+    attr_reader :code_cov
+    attr_reader :repository
+    attr_reader :documentation_site
+    attr_reader :documentation_site_url
 
-    const :assigned_globs, T::Array[String]
-    const :unassigned_globs, T::Array[String]
-    const :unbuilt_gems_path, T.nilable(String)
-    const :skip_features_validation, T::Boolean
-    const :raw_hash, T::Hash[T.untyped, T.untyped]
-    const :skip_code_ownership, T::Boolean
-    const :require_assignment_for_teams, T.nilable(T::Array[String])
-    const :ignore_feature_definitions, T::Boolean
-    const :code_cov, T::Hash[String, T.nilable(String)]
-    const :repository, T::Hash[String, T.nilable(String)]
-    const :documentation_site, T::Hash[String, T.untyped]
-    const :documentation_site_url, T.nilable(String)
+    def initialize(
+      assigned_globs: nil,
+      unassigned_globs: nil,
+      unbuilt_gems_path: nil,
+      skip_features_validation: nil,
+      raw_hash: nil,
+      skip_code_ownership: nil,
+      require_assignment_for_teams: nil,
+      ignore_feature_definitions: nil,
+      code_cov: nil,
+      repository: nil,
+      documentation_site: nil,
+      documentation_site_url: nil
+    )
+      @assigned_globs = assigned_globs
+      @unassigned_globs = unassigned_globs
+      @unbuilt_gems_path = unbuilt_gems_path
+      @skip_features_validation = skip_features_validation
+      @raw_hash = raw_hash
+      @skip_code_ownership = skip_code_ownership
+      @require_assignment_for_teams = require_assignment_for_teams
+      @ignore_feature_definitions = ignore_feature_definitions
+      @code_cov = code_cov
+      @repository = repository
+      @documentation_site = documentation_site
+      @documentation_site_url = documentation_site_url
+    end
 
-    sig { returns(Configuration) }
     def self.fetch
       config_hash = YAML.load_file('.feature_map/config.yml')
 

data/lib/feature_map/constants.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-# typed: strict
-
 module FeatureMap
   module Constants
-    SINGLE_LINE_COMMENT_PATTERNS = T.let(['#', '//'].map { |r| Regexp.escape(r) }.freeze, T::Array[String])
-    MULTILINE_COMMENT_START_PATTERNS = T.let(['/*', '<!--', '"""', "'''"].map { |r| Regexp.escape(r) }.freeze, T::Array[String])
-    MULTILINE_COMMENT_END_PATTERNS = T.let(['*/', '-->', '"""', "'''"].map { |r| Regexp.escape(r) }.freeze, T::Array[String])
+    SINGLE_LINE_COMMENT_PATTERNS = ['#', '//'].map { |r| Regexp.escape(r) }.freeze
+    MULTILINE_COMMENT_START_PATTERNS = ['/*', '<!--', '"""', "'''"].map { |r| Regexp.escape(r) }.freeze
+    MULTILINE_COMMENT_END_PATTERNS = ['*/', '-->', '"""', "'''"].map { |r| Regexp.escape(r) }.freeze
   end
 end

data/lib/feature_map/mapper.rb

@@ -1,25 +1,13 @@
 # frozen_string_literal: true
 
-# typed: strict
-
 module FeatureMap
   module Mapper
-    extend T::Sig
-    extend T::Helpers
-
-    interface!
-
     class << self
-      extend T::Sig
-
-      sig { params(base: T::Class[Mapper]).void }
       def included(base)
-        @mappers ||= T.let(@mappers, T.nilable(T::Array[T::Class[Mapper]]))
         @mappers ||= []
         @mappers << base
       end
 
-      sig { returns(T::Array[Mapper]) }
       def all
         (@mappers || []).map(&:new)
       end
@@ -28,36 +16,22 @@ module FeatureMap
     #
     # This should be fast when run with ONE file
     #
-    sig do
-      abstract.params(file: String)
-        .returns(T.nilable(CodeFeatures::Feature))
-    end
     def map_file_to_feature(file); end
 
     #
     # This should be fast when run with MANY files
     #
-    sig do
-      abstract.params(files: T::Array[String])
-        .returns(T::Hash[String, CodeFeatures::Feature])
-    end
     def globs_to_feature(files); end
 
     #
     # This should be fast when run with MANY files
     #
-    sig do
-      abstract.params(cache: GlobsToAssignedFeatureMap, files: T::Array[String]).returns(GlobsToAssignedFeatureMap)
-    end
     def update_cache(cache, files); end
 
-    sig { abstract.returns(String) }
     def description; end
 
-    sig { abstract.void }
     def bust_caches!; end
 
-    sig { returns(Private::GlobCache) }
     def self.to_glob_cache
       glob_to_feature_map_by_mapper_description = {}
 

data/lib/feature_map/output_color.rb

@@ -1,41 +1,30 @@
 # frozen_string_literal: true
 
-# typed: strict
-
 module OutputColor
-  extend T::Sig
-
-  sig { params(color_code: Integer, text: String).returns(String) }
   def self.colorize(color_code, text)
     "\e[#{color_code}m#{text}\e[0m"
   end
 
-  sig { params(text: String).returns(String) }
   def self.red(text)
     colorize(31, text)
   end
 
-  sig { params(text: String).returns(String) }
   def self.green(text)
     colorize(32, text)
   end
 
-  sig { params(text: String).returns(String) }
   def self.yellow(text)
     colorize(33, text)
   end
 
-  sig { params(text: String).returns(String) }
   def self.blue(text)
     colorize(34, text)
   end
 
-  sig { params(text: String).returns(String) }
   def self.pink(text)
     colorize(35, text)
   end
 
-  sig { params(text: String).returns(String) }
   def self.light_blue(text)
     colorize(36, text)
   end

data/lib/feature_map/private/additional_metrics_file.rb

@@ -1,44 +1,22 @@
-# typed: strict
 # frozen_string_literal: true
 
 module FeatureMap
   module Private
     class AdditionalMetricsFile
-      extend T::Sig
-
       class FileContentError < StandardError; end
 
       FEATURES_KEY = 'features'
 
-      FeatureName = T.type_alias { String }
-
-      FeatureMetrics = T.type_alias do
-        T::Hash[
-          String,
-          T.any(Integer, Float, T::Hash[String, String])
-        ]
-      end
-
-      FeaturesContent = T.type_alias do
-        T::Hash[
-          FeatureName,
-          FeatureMetrics
-        ]
-      end
-
-      sig { params(metrics: T::Hash[String, T.untyped], test_coverage: T::Hash[String, T.untyped], health_config: T::Hash[String, T.untyped]).void }
       def self.write!(metrics, test_coverage, health_config)
         FileUtils.mkdir_p(path.dirname) if !path.dirname.exist?
 
         path.write([header_comment, "\n", generate_content(metrics, test_coverage, health_config).to_yaml].join)
       end
 
-      sig { returns(Pathname) }
       def self.path
         Pathname.pwd.join('.feature_map/additional-metrics.yml')
       end
 
-      sig { returns(String) }
       def self.header_comment
         <<~HEADER
           # STOP! - DO NOT EDIT THIS FILE MANUALLY
@@ -53,35 +31,26 @@ module FeatureMap
         HEADER
       end
 
-      sig { params(feature_metrics: T::Hash[String, T.untyped], feature_test_coverage: T::Hash[String, T.untyped], health_config: T::Hash[String, T.untyped]).returns(T::Hash[String, FeaturesContent]) }
       def self.generate_content(feature_metrics, feature_test_coverage, health_config)
-        feature_additional_metrics = T.let({}, FeaturesContent)
+        feature_additional_metrics = {}
 
-        cyclomatic_complexity_ratios = feature_metrics.map { |_k, m| m[FeatureMetricsCalculator::COMPLEXITY_RATIO_METRIC] }.compact
-        encapsulation_ratios = feature_metrics.map { |_k, m| m[FeatureMetricsCalculator::ENCAPSULATION_RATIO_METRIC] }.compact
-        feature_sizes = feature_metrics.map { |_k, m| m[FeatureMetricsCalculator::LINES_OF_CODE_METRIC] }.compact
-        test_coverage_ratios = feature_test_coverage.map { |_k, c| c[TestCoverageFile::COVERAGE_RATIO] }.compact
+        percentile_metrics = PercentileMetricsCalculator.new(metrics: feature_metrics, test_coverage: feature_test_coverage)
+        health_calculator = HealthCalculator.new(percentile_metrics: percentile_metrics, health_config: health_config)
 
         Private.feature_file_assignments.each_key do |feature_name|
-          cyclomatic_complexity = calculate(cyclomatic_complexity_ratios, feature_metrics.dig(feature_name, FeatureMetricsCalculator::COMPLEXITY_RATIO_METRIC) || 0)
-          encapsulation = calculate(encapsulation_ratios, feature_metrics.dig(feature_name, FeatureMetricsCalculator::ENCAPSULATION_RATIO_METRIC) || 0)
-          feature_size = calculate(feature_sizes, feature_metrics.dig(feature_name, FeatureMetricsCalculator::LINES_OF_CODE_METRIC) || 0)
-          test_coverage = calculate(test_coverage_ratios, feature_test_coverage.dig(feature_name, TestCoverageFile::COVERAGE_RATIO) || 0)
-          health = health_score_for(cyclomatic_complexity, encapsulation, test_coverage, health_config)
-
           feature_additional_metrics[feature_name] = {
-            'cyclomatic_complexity' => cyclomatic_complexity,
-            'encapsulation' => encapsulation,
-            'feature_size' => feature_size,
-            'test_coverage' => test_coverage,
-            'health' => health
+            'cyclomatic_complexity' => percentile_metrics.cyclomatic_complexity_for(feature_name),
+            'encapsulation' => percentile_metrics.encapsulation_for(feature_name),
+            'feature_size' => percentile_metrics.feature_size_for(feature_name),
+            'test_coverage' => percentile_metrics.test_coverage_for(feature_name),
+            'todo_count' => percentile_metrics.todo_count_for(feature_name),
+            'health' => health_calculator.health_score_for(feature_name)
           }
         end
 
         { FEATURES_KEY => feature_additional_metrics }
       end
 
-      sig { returns(FeaturesContent) }
       def self.load_features!
         metrics_content = YAML.load_file(path)
 
@@ -93,69 +62,6 @@ module FeatureMap
       rescue Errno::ENOENT
         raise FileContentError, "No feature metrics file found at #{path}. Use `bin/featuremap additional_metrics` to generate it and try again."
       end
-
-      sig { params(collection: T::Array[T.any(Integer, Float)], score: T.any(Integer, Float)).returns({ 'percentile' => Float, 'percent_of_max' => Integer, 'score' => T.any(Integer, Float) }) }
-      def self.calculate(collection, score)
-        max = collection.max || 0
-        percentile = percentile_of(collection, score)
-        percent_of_max = max.zero? ? 0 : ((score.to_f / max) * 100).round.to_i
-
-        { 'percentile' => percentile, 'percent_of_max' => percent_of_max, 'score' => score }
-      end
-
-      sig { params(arr: T::Array[T.any(Integer, Float)], val: T.any(Integer, Float)).returns(Float) }
-      def self.percentile_of(arr, val)
-        return 0.0 if arr.empty?
-
-        ensure_array_of_floats = arr.map(&:to_f)
-        ensure_float_value = val.to_f
-
-        below_or_equal_count = ensure_array_of_floats.reduce(0) do |acc, v|
-          if v < ensure_float_value
-            acc + 1
-          elsif v == ensure_float_value
-            acc + 0.5
-          else
-            acc
-          end
-        end
-
-        ((100 * below_or_equal_count) / ensure_array_of_floats.length).to_f
-      end
-
-      sig { params(awardable_points: Integer, score: T.any(Float, Integer), score_threshold: Integer, percent_of_max: T.nilable(T.any(Integer, Float)), percent_of_max_threshold: T.nilable(T.any(Integer, Float))).returns({ 'awardable_points' => Integer, 'health_score' => T.any(Float, Integer), 'close_to_maximum_score' => T::Boolean, 'exceeds_score_threshold' => T::Boolean }) }
-      def self.health_score_component(awardable_points, score, score_threshold, percent_of_max = 0, percent_of_max_threshold = 100)
-        close_to_maximum_score = T.must(percent_of_max) >= T.must(percent_of_max_threshold)
-        exceeds_score_threshold = score >= score_threshold
-
-        if close_to_maximum_score || exceeds_score_threshold
-          { 'awardable_points' => awardable_points, 'health_score' => awardable_points, 'close_to_maximum_score' => close_to_maximum_score, 'exceeds_score_threshold' => exceeds_score_threshold }
-        else
-          { 'awardable_points' => awardable_points, 'health_score' => (score.to_f / score_threshold) * awardable_points, 'close_to_maximum_score' => close_to_maximum_score, 'exceeds_score_threshold' => exceeds_score_threshold }
-        end
-      end
-
-      sig {
-        params(
-          encapsulation: T::Hash[String, T.any(Integer, Float)],
-          cyclomatic_complexity: T::Hash[String, T.any(Integer, Float)],
-          test_coverage: T::Hash[String, T.any(Integer, Float)],
-          health_config: T::Hash[String, T.untyped]
-        ).returns(T::Hash[String, T.untyped])
-      }
-      def self.health_score_for(encapsulation, cyclomatic_complexity, test_coverage, health_config)
-        cyclomatic_complexity_config = health_config['components']['cyclomatic_complexity']
-        encapsulation_config = health_config['components']['encapsulation']
-        test_coverage_config = health_config['components']['test_coverage']
-
-        test_coverage_component = health_score_component(test_coverage_config['weight'], T.must(test_coverage['score']), test_coverage_config['score_threshold'])
-        cyclomatic_complexity_component = health_score_component(cyclomatic_complexity_config['weight'], T.must(cyclomatic_complexity['percentile']), cyclomatic_complexity_config['score_threshold'], cyclomatic_complexity['percent_of_max'], 100 - cyclomatic_complexity_config['minimum_variance'])
-        encapsulation_component = health_score_component(encapsulation_config['weight'], T.must(encapsulation['percentile']), encapsulation_config['score_threshold'], encapsulation['percent_of_max'], 100 - encapsulation_config['minimum_variance'])
-
-        overall = test_coverage_component['health_score'] + cyclomatic_complexity_component['health_score'] + encapsulation_component['health_score']
-
-        { 'test_coverage_component' => test_coverage_component, 'cyclomatic_complexity_component' => cyclomatic_complexity_component, 'encapsulation_component' => encapsulation_component, 'overall' => overall }
-      end
     end
   end
 end