Merge pull request #36 from fastruby/rename/skunk-score

Rename/skunk score

Author: etagwerker

.gitignore

@@ -6,6 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+/test/support/
 
 .byebug_history
 

CHANGELOG.md

@@ -4,7 +4,9 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased] [(commits)](https://github.com/fastruby/skunk/compare/v0.4.0...HEAD)
+## [Unreleased] [(commits)](https://github.com/fastruby/skunk/compare/v0.4.2...HEAD)
+
+* [FEATURE] Rename the tech debt metric: StinkScore => SkunkScore. It's a little friendlier.
 
 ## [0.4.2] [(commits)](https://github.com/fastruby/skunk/compare/v0.4.1...v0.4.2)
 * [BUGFIX] Fixes table width issues by rounding values (by [@etagwerker][])

README.md

@@ -5,18 +5,18 @@
 
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v1.4%20adopted-ff69b4.svg)](CODE_OF_CONDUCT.md) [![Build Status](https://travis-ci.org/fastruby/skunk.svg?branch=master)](https://travis-ci.org/fastruby/skunk) [![Maintainability](https://api.codeclimate.com/v1/badges/3e33d701ced16eee2420/maintainability)](https://codeclimate.com/github/fastruby/skunk/maintainability) [![Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/skunk) [![codecov](https://codecov.io/gh/fastruby/skunk/branch/master/graph/badge.svg)](https://codecov.io/gh/fastruby/skunk)
 
-A RubyCritic extension to calculate StinkScore for a file or project.
+A RubyCritic extension to calculate SkunkScore for a file or project.
 
-## What is the StinkScore?
+## What is the SkunkScore?
 
-The StinkScore is a value that assesses the technical debt of a module. It takes
+The SkunkScore is a value that assesses the technical debt of a module. It takes
 into account:
 
 - Code Complexity
 - Code Smells
 - Code Coverage
 
-The main goal of the StinkScore is to serve as a compass in your next
+The main goal of the SkunkScore is to serve as a compass in your next
 refactoring adventure. It will help you answer these questions:
 
 - What can I do to pay off technical debt?
@@ -89,7 +89,7 @@ running simple_cov
 .............
 New critique at file:////Users/etagwerker/Projects/fastruby/skunk/tmp/rubycritic/overview.html
 +-----------------------------------------------------+----------------------------+----------------------------+----------------------------+----------------------------+----------------------------+
-| file                                                | stink_score                | churn_times_cost           | churn                      | cost                       | coverage                   |
+| file                                                | skunk_score                | churn_times_cost           | churn                      | cost                       | coverage                   |
 +-----------------------------------------------------+----------------------------+----------------------------+----------------------------+----------------------------+----------------------------+
 | lib/skunk/cli/commands/default.rb                   | 166.44                     | 1.6643999999999999         | 3                          | 0.5548                     | 0                          |
 | lib/skunk/cli/application.rb                        | 139.2                      | 1.392                      | 3                          | 0.46399999999999997        | 0                          |
@@ -106,10 +106,10 @@ New critique at file:////Users/etagwerker/Projects/fastruby/skunk/tmp/rubycritic
 | lib/skunk/cli/commands/help.rb                      | 0.0                        | 0.0                        | 2                          | 0.0                        | 0                          |
 +-----------------------------------------------------+----------------------------+----------------------------+----------------------------+----------------------------+----------------------------+
 
-StinkScore Total: 612.31
+SkunkScore Total: 612.31
 Modules Analysed: 13
-StinkScore Average: 0.47100769230769230769230769231e2
-Worst StinkScore: 166.44 (lib/skunk/cli/commands/default.rb)
+SkunkScore Average: 0.47100769230769230769230769231e2
+Worst SkunkScore: 166.44 (lib/skunk/cli/commands/default.rb)
 ```
 
 The command will run `rubycritic` and it will try to load code coverage data
@@ -125,7 +125,7 @@ Simply run:
 skunk -b <target-branch-name>
 ```
 
-Then get a StinkScore average comparison:
+Then get a SkunkScore average comparison:
 
 ```
 $ skunk -b master
@@ -159,28 +159,28 @@ running churn
 .................
 running simple_cov
 .................
-Base branch (master) average stink score: 290.53999999999996
-Feature branch (feature/compare) average stink score: 340.3005882352941
+Base branch (master) average skunk score: 290.53999999999996
+Feature branch (feature/compare) average skunk score: 340.3005882352941
 Score: 340.3
 ```
 
 This should give you an idea if you're moving in the right direction or not.
 
 ## Known Issues
 
-The StinkScore should be calculated per method. This would provide a more accurate
-representation of the average StinkScore in a module.
+The SkunkScore should be calculated per method. This would provide a more accurate
+representation of the average SkunkScore in a module.
 
-I think that the StinkScore of a module should be the average of the StinkScores of
+I think that the SkunkScore of a module should be the average of the SkunkScores of
 all of its methods.
 
-Right now the StinkScore is calculated using the totals for a module:
+Right now the SkunkScore is calculated using the totals for a module:
 
 - Total Code Coverage Percentage per Module
 - Total Churn per Module
 - Total Cost per Module
 
-For more details, feel free to review and improve this method: [RubyCritic::AnalysedModule#stink_score]
+For more details, feel free to review and improve this method: [RubyCritic::AnalysedModule#skunk_score]
 
 ## Development
 

lib/skunk.rb

@@ -2,7 +2,7 @@
 
 require "skunk/version"
 
-# Knows how to calculate the `StinkScore` for each file analyzed by `RubyCritic`
+# Knows how to calculate the `SkunkScore` for each file analyzed by `RubyCritic`
 # and `SimpleCov`
 module Skunk
 end

lib/skunk/cli/commands/compare.rb

@@ -7,13 +7,13 @@
 # nodoc #
 module Skunk
   module Command
-    # Knows how to compare two branches and their stink score average
+    # Knows how to compare two branches and their skunk score average
     class Compare < RubyCritic::Command::Compare
       # switch branch and analyse files but don't generate a report
       def analyse_branch(branch)
         ::RubyCritic::SourceControlSystem::Git.switch_branch(::RubyCritic::Config.send(branch))
         critic = critique(branch)
-        ::RubyCritic::Config.send(:"#{branch}_score=", critic.stink_score_average)
+        ::RubyCritic::Config.send(:"#{branch}_score=", critic.skunk_score_average)
         ::RubyCritic::Config.root = branch_directory(branch)
       end
 
@@ -30,9 +30,9 @@ def analyse_modified_files
       # create a txt file with the branch score details
       def build_details
         details = "Base branch (#{::RubyCritic::Config.base_branch}) "\
-          "average stink score: #{::RubyCritic::Config.base_branch_score.to_f.round(2)} \n"\
+          "average skunk score: #{::RubyCritic::Config.base_branch_score.to_f.round(2)} \n"\
           "Feature branch (#{::RubyCritic::Config.feature_branch}) "\
-          "average stink score: #{::RubyCritic::Config.feature_branch_score.to_f.round(2)} \n"
+          "average skunk score: #{::RubyCritic::Config.feature_branch_score.to_f.round(2)} \n"
         Skunk::Command::Output.create_directory(::RubyCritic::Config.compare_root_directory)
         File.open(build_details_path, "w") { |file| file.write(details) }
         puts details

lib/skunk/cli/commands/status_reporter.rb

@@ -10,23 +10,23 @@ module Command
     class StatusReporter < RubyCritic::Command::StatusReporter
       attr_accessor :analysed_modules
 
-      HEADINGS = %w[file stink_score churn_times_cost churn cost coverage].freeze
+      HEADINGS = %w[file skunk_score churn_times_cost churn cost coverage].freeze
       HEADINGS_WITHOUT_FILE = HEADINGS - %w[file]
       HEADINGS_WITHOUT_FILE_WIDTH = HEADINGS_WITHOUT_FILE.size * 17 # padding
 
       TEMPLATE = ERB.new(<<-TEMPL
 <%= _ttable %>\n
-StinkScore Total: <%= total_stink_score %>
+SkunkScore Total: <%= total_skunk_score %>
 Modules Analysed: <%= analysed_modules_count %>
-StinkScore Average: <%= stink_score_average %>
-<% if worst %>Worst StinkScore: <%= worst.stink_score %> (<%= worst.pathname %>)<% end %>
+SkunkScore Average: <%= skunk_score_average %>
+<% if worst %>Worst SkunkScore: <%= worst.skunk_score %> (<%= worst.pathname %>)<% end %>
 
 Generated with Skunk v<%= Skunk::VERSION %>
 TEMPL
                         )
 
       # Returns a status message with a table of all analysed_modules and
-      # a stink score average
+      # a skunk score average
       def update_status_message
         opts = table_options.merge(headings: HEADINGS, rows: table)
 
@@ -52,21 +52,21 @@ def worst
       end
 
       def sorted_modules
-        @sorted_modules ||= non_test_modules.sort_by(&:stink_score).reverse!
+        @sorted_modules ||= non_test_modules.sort_by(&:skunk_score).reverse!
       end
 
-      def total_stink_score
-        @total_stink_score ||= non_test_modules.sum(&:stink_score)
+      def total_skunk_score
+        @total_skunk_score ||= non_test_modules.sum(&:skunk_score)
       end
 
       def total_churn_times_cost
         non_test_modules.sum(&:churn_times_cost)
       end
 
-      def stink_score_average
+      def skunk_score_average
         return 0 if analysed_modules_count.zero?
 
-        (total_stink_score.to_d / analysed_modules_count).to_f.round(2)
+        (total_skunk_score.to_d / analysed_modules_count).to_f.round(2)
       end
 
       def table_options
@@ -83,7 +83,7 @@ def table
         sorted_modules.map do |a_mod|
           [
             a_mod.pathname,
-            a_mod.stink_score,
+            a_mod.skunk_score,
             a_mod.churn_times_cost,
             a_mod.churn,
             a_mod.cost.round(2),

lib/skunk/rubycritic/analysed_module.rb

@@ -3,34 +3,34 @@
 require "rubycritic/core/analysed_module"
 
 module RubyCritic
-  # Monkey-patches RubyCritic::AnalysedModule to add a stink_score method
+  # Monkey-patches RubyCritic::AnalysedModule to add a skunk_score method
   class AnalysedModule
     PERFECT_COVERAGE = 100
 
-    # Returns a numeric value that represents the stink_score of a module:
+    # Returns a numeric value that represents the skunk_score of a module:
     #
-    # If module is perfectly covered, stink score is the same as the
+    # If module is perfectly covered, skunk score is the same as the
     # `churn_times_cost`
     #
-    # If module has no coverage, stink score is a penalized value of
+    # If module has no coverage, skunk score is a penalized value of
     # `churn_times_cost`
     #
-    # For now the stink_score is calculated by multiplying `churn_times_cost`
+    # For now the skunk_score is calculated by multiplying `churn_times_cost`
     # times the lack of coverage.
     #
     # For example:
     #
     # When `churn_times_cost` is 100 and module is perfectly covered:
-    # stink_score => 100
+    # skunk_score => 100
     #
     # When `churn_times_cost` is 100 and module is not covered at all:
-    # stink_score => 100 * 100 = 10_000
+    # skunk_score => 100 * 100 = 10_000
     #
     # When `churn_times_cost` is 100 and module is covered at 75%:
-    # stink_score => 100 * 25 (percentage uncovered) = 2_500
+    # skunk_score => 100 * 25 (percentage uncovered) = 2_500
     #
     # @return [Float]
-    def stink_score
+    def skunk_score
       return cost.round(2) if coverage == PERFECT_COVERAGE
 
       (cost * (PERFECT_COVERAGE - coverage.to_i)).round(2)

lib/skunk/rubycritic/analysed_modules_collection.rb

@@ -5,10 +5,10 @@
 module RubyCritic
   # nodoc #
   class AnalysedModulesCollection
-    def stink_score_average
+    def skunk_score_average
       num_modules = @modules.size
       if num_modules.positive?
-        sum(&:stink_score) / num_modules.to_f
+        sum(&:skunk_score) / num_modules.to_f
       else
         0.0
       end

samples/rubycritic/analysed_module.rb

@@ -3,34 +3,34 @@
 require "rubycritic/core/analysed_module"
 
 module RubyCritic
-  # Monkey-patches RubyCritic::AnalysedModule to add a stink_score method
+  # Monkey-patches RubyCritic::AnalysedModule to add a skunk_score method
   class AnalysedModule
     PERFECT_COVERAGE = 100
 
-    # Returns a numeric value that represents the stink_score of a module:
+    # Returns a numeric value that represents the skunk_score of a module:
     #
-    # If module is perfectly covered, stink score is the same as the
+    # If module is perfectly covered, skunk score is the same as the
     # `churn_times_cost`
     #
-    # If module has no coverage, stink score is a penalized value of
+    # If module has no coverage, skunk score is a penalized value of
     # `churn_times_cost`
     #
-    # For now the stink_score is calculated by multiplying `churn_times_cost`
+    # For now the skunk_score is calculated by multiplying `churn_times_cost`
     # times the lack of coverage.
     #
     # For example:
     #
     # When `churn_times_cost` is 100 and module is perfectly covered:
-    # stink_score => 100
+    # skunk_score => 100
     #
     # When `churn_times_cost` is 100 and module is not covered at all:
-    # stink_score => 100 * 100 = 10_000
+    # skunk_score => 100 * 100 = 10_000
     #
     # When `churn_times_cost` is 100 and module is covered at 75%:
-    # stink_score => 100 * 25 (percentage uncovered) = 2_500
+    # skunk_score => 100 * 25 (percentage uncovered) = 2_500
     #
     # @return [Float]
-    def stink_score
+    def skunk_score
       return cost.round(2) if coverage == PERFECT_COVERAGE
 
       (cost * (PERFECT_COVERAGE - coverage.to_i)).round(2)

skunk.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["[email protected]"]
   spec.licenses      = ["MIT"]
   spec.summary       = "A library to assess code quality vs. code coverage"
-  spec.description   = "Knows how to calculate the StinkScore for a Ruby file"
+  spec.description   = "Knows how to calculate the SkunkScore for a set of Ruby modules"
   spec.homepage      = "https://github.com/fastruby/skunk"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'