skunk 0.3.1 → 0.5.0

data/README.md

@@ -1,25 +1,27 @@
 # Skunk
 
-[![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)
+![skunk](https://github.com/fastruby/skunk/raw/master/logo.png)
 
-A RubyCritic extension to calculate StinkScore for a file or project.
+[![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)
 
-## What is the StinkScore?
+A RubyCritic extension to calculate SkunkScore for a file or project.
 
-The StinkScore is a value that assesses the quality of a module. It takes into
-account:
+## What is the SkunkScore?
+
+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?
 - What are the most complicated files with the least code coverage?
 - What are good candidates for your next test-writing efforts?
-- What are good candidates for your nest refactoring efforts?
+- What are good candidates for your next refactoring efforts?
 
 The formula is not perfect and it is certainly controversial, so any feedback is
 welcome as a new issue!
@@ -42,7 +44,20 @@ Or install it yourself as:
 
 ## Usage
 
-### Getting a sorted list of stinkiest files
+### Help details
+
+There are not that many options but here they are:
+
+```
+skunk -h
+Usage: skunk [options] [paths]
+    -b, --branch BRANCH              Set branch to compare
+    -o, --out FILE                   Output report to file
+    -v, --version                    Show gem's version
+    -h, --help                       Show this message
+```
+
+### Getting a sorted list of smelly files
 
 To get the best results, make sure that you have `coverage/.resultset.json` in
 your application directory. That way `skunk` knows what's the status of your
@@ -54,13 +69,10 @@ Then simply run:
 skunk
 ```
 
-Then get a list of stinky files:
+Then get a list of smelly files:
 
 ```
 $ skunk
-warning: parser/current is loading parser/ruby26, which recognizes
-warning: 2.6.5-compliant syntax, but you are running 2.6.2.
-warning: please see https://github.com/whitequark/parser#compatibility-with-ruby-mri.
 running flay smells
 
 running flog smells
@@ -77,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                          |
@@ -94,14 +106,14 @@ 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
-from your `.resultset.json` file.
+from your `coverage/.resultset.json` file.
 
 Skunk's report will be in the console. Use it wisely. :)
 
@@ -113,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
@@ -147,28 +159,63 @@ 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.
 
+### Sharing results
+
+If you want to quickly share the results of your report, you can use an
+environment variable:
+
+```
+SHARE=true skunk app/
+...
+SkunkScore Total: 126.99
+Modules Analysed: 17
+SkunkScore Average: 7.47
+Worst SkunkScore: 41.92 (lib/skunk/cli/commands/status_sharer.rb)
+
+Generated with Skunk v0.5.0
+Shared at: https://skunk.fastruby.io/k
+```
+
+Results will be posted by default to https://skunk.fastruby.io which is a free
+and open source Ruby on Rails application sponsored by
+[OmbuLabs](https://www.ombulabs.com) ([source code](https://github.com/fastruby/skunk.fyi)).
+
+If you prefer to post results to your own server, you can do so:
+
+```
+SHARE_URL=https://path.to.your.skunk-fyi-server.example.com skunk app/
+...
+SkunkScore Total: 126.99
+Modules Analysed: 17
+SkunkScore Average: 7.47
+Worst SkunkScore: 41.92 (lib/skunk/cli/commands/status_sharer.rb)
+
+Generated with Skunk v0.5.0
+Shared at: https://path.to.your.skunk-fyi-server.example.com/k
+```
+
 ## 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
 
@@ -179,3 +226,9 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/fastruby/skunk/issues.
+
+## Sponsorship
+
+![FastRuby.io | Rails Upgrade Services](https://github.com/fastruby/skunk/raw/master/fastruby-logo.png)
+
+`skunk` is maintained and funded by [FastRuby.io](https://fastruby.io). The names and logos for FastRuby.io are trademarks of The Lean Software Boutique LLC.

data/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

data/lib/skunk/cli/application.rb

@@ -1,25 +1,60 @@
 # frozen_string_literal: true
 
+require "rubycritic/cli/options"
+require "rubycritic/cli/application"
+
 require "skunk"
 require "skunk/rubycritic/analysed_module"
 require "skunk/cli/options"
 require "skunk/cli/command_factory"
-
-require "rubycritic/cli/application"
+require "skunk/cli/commands/status_sharer"
 
 module Skunk
   module Cli
     # Knows how to execute command line commands
+    # :reek:InstanceVariableAssumption
     class Application < RubyCritic::Cli::Application
+      COVERAGE_FILE = "coverage/.resultset.json"
+
+      def initialize(argv)
+        @options = Skunk::Cli::Options.new(argv)
+      end
+
+      # :reek:UncommunicativeVariableName
       def execute
-        parsed_options = @options.parse.to_h
-        reporter = Skunk::Cli::CommandFactory.create(parsed_options).execute
+        warn_coverage_info unless File.exist?(COVERAGE_FILE)
+
+        # :reek:NilCheck
+        @parsed_options = @options.parse.to_h
+        command = Skunk::Cli::CommandFactory.create(@parsed_options)
+        reporter = command.execute
+
         print(reporter.status_message)
+        share_status_message = command.share(reporter)
+        print(share_status_message)
+
         reporter.status
-      rescue OptionParser::InvalidOption => error
-        warn "Error: #{error}"
+      rescue OptionParser::InvalidOption => e
+        warn "Error: #{e}"
         STATUS_ERROR
       end
+
+      private
+
+      def warn_coverage_info
+        warn "warning: Couldn't find coverage info at #{COVERAGE_FILE}."
+        warn "warning: Having no coverage metrics will make your SkunkScore worse."
+      end
+
+      # :reek:NilCheck
+      def print(message)
+        filename = @parsed_options[:output_filename]
+        if filename.nil?
+          $stdout.puts(message)
+        else
+          File.open(filename, "a") { |file| file << message }
+        end
+      end
     end
   end
 end

data/lib/skunk/cli/commands/base.rb

@@ -14,6 +14,8 @@ module Skunk
           @options = options
           @status_reporter = Skunk::Command::StatusReporter.new(@options)
         end
+
+        def share(_); end
       end
     end
   end

data/lib/skunk/cli/commands/compare.rb

@@ -2,17 +2,19 @@
 
 require "rubycritic/commands/compare"
 require "skunk/rubycritic/analysed_modules_collection"
+require "skunk/cli/commands/output"
+require "skunk/cli/commands/compare_score"
 
 # 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
 
@@ -28,10 +30,14 @@ module Skunk
 
       # 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} \n"\
-                  "Feature branch (#{::RubyCritic::Config.feature_branch}) "\
-                  "average stink score: #{::RubyCritic::Config.feature_branch_score} \n"
+        details = CompareScore.new(
+          ::RubyCritic::Config.base_branch,
+          ::RubyCritic::Config.feature_branch,
+          ::RubyCritic::Config.base_branch_score.to_f.round(2),
+          ::RubyCritic::Config.feature_branch_score.to_f.round(2)
+        ).message
+
+        Skunk::Command::Output.create_directory(::RubyCritic::Config.compare_root_directory)
         File.open(build_details_path, "w") { |file| file.write(details) }
         puts details
       end

data/lib/skunk/cli/commands/compare_score.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# nodoc #
+module Skunk
+  module Command
+    # Knows how to describe score evolution between two branches
+    class CompareScore
+      def initialize(base_branch, feature_branch, base_branch_score, feature_branch_score)
+        @base_branch = base_branch
+        @feature_branch = feature_branch
+        @base_branch_score = base_branch_score
+        @feature_branch_score = feature_branch_score
+      end
+
+      def message
+        "Base branch (#{@base_branch}) "\
+          "average skunk score: #{@base_branch_score} \n"\
+          "Feature branch (#{@feature_branch}) "\
+          "average skunk score: #{@feature_branch_score} \n"\
+          "#{score_evolution_message}"
+      end
+
+      def score_evolution_message
+        "Skunk score average is #{score_evolution} #{score_evolution_appreciation} \n"
+      end
+
+      def score_evolution_appreciation
+        @feature_branch_score > @base_branch_score ? "worse" : "better"
+      end
+
+      def score_evolution
+        return "Infinitely" if @base_branch_score.zero?
+
+        precentage = (100 * (@base_branch_score - @feature_branch_score) / @base_branch_score)
+        "#{precentage.round(0).abs}%"
+      end
+    end
+  end
+end

data/lib/skunk/cli/commands/default.rb

@@ -16,20 +16,41 @@ module Skunk
       class Default < RubyCritic::Command::Default
         def initialize(options)
           super
-          @status_reporter = Skunk::Command::StatusReporter.new(@options)
+          @options = options
+          @status_reporter = Skunk::Command::StatusReporter.new(options)
         end
 
+        # It generates a report and it returns an instance of
+        # Skunk::Command::StatusReporter
+        #
+        # @return [Skunk::Command::StatusReporter]
         def execute
           RubyCritic::Config.formats = []
 
           report(critique)
+
           status_reporter
         end
 
+        # It connects the Skunk::Command::StatusReporter with the collection
+        # of analysed modules.
+        #
+        # @param [RubyCritic::AnalysedModulesCollection] A collection of analysed modules
         def report(analysed_modules)
           status_reporter.analysed_modules = analysed_modules
           status_reporter.score = analysed_modules.score
         end
+
+        # It shares the report using SHARE_URL or https://skunk.fastruby.io. It
+        # will post all results in JSON format and return a status message.
+        #
+        # @param [Skunk::Command::StatusReporter] A status reporter with analysed modules
+        # :reek:FeatureEnvy
+        def share(reporter)
+          sharer = Skunk::Command::StatusSharer.new(@options)
+          sharer.status_reporter = reporter
+          sharer.share
+        end
       end
     end
   end

data/lib/skunk/cli/commands/help.rb

@@ -1,11 +1,22 @@
 # frozen_string_literal: true
 
 require "skunk/cli/commands/base"
+require "rubycritic/commands/help"
 
 module Skunk
   module Cli
     module Command
-      class Help < RubyCritic::Command::Help
+      # Knows how to guide user into using `skunk` properly
+      class Help < Skunk::Cli::Command::Base
+        # Outputs a help message
+        def execute
+          puts options[:help_text]
+          status_reporter
+        end
+
+        private
+
+        attr_reader :options, :status_reporter
       end
     end
   end

data/lib/skunk/cli/commands/output.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Skunk
+  module Command
+    # Implements the needed methods for a successful compare output
+    class Output
+      def self.create_directory(directory)
+        FileUtils.mkdir_p(directory) unless File.exist?(directory)
+      end
+    end
+  end
+end

data/lib/skunk/cli/commands/status_reporter.rb

@@ -10,23 +10,27 @@ module Skunk
     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 %>
+<%= _ttable %>\n
+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)
 
-        ttable = Terminal::Table.new(opts)
+        _ttable = Terminal::Table.new(opts)
 
         @status_message = TEMPLATE.result(binding)
       end
@@ -39,7 +43,8 @@ TEMPL
 
       def non_test_modules
         @non_test_modules ||= analysed_modules.reject do |a_module|
-          a_module.pathname.to_s.start_with?("test", "spec")
+          module_path = a_module.pathname.dirname.to_s
+          module_path.start_with?("test", "spec") || module_path.end_with?("test", "spec")
         end
       end
 
@@ -48,27 +53,29 @@ TEMPL
       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.map(&:stink_score).inject(0.0, :+)
+      def total_skunk_score
+        @total_skunk_score ||= non_test_modules.sum(&:skunk_score)
       end
 
       def total_churn_times_cost
-        non_test_modules.map(&:churn_times_cost).sum
+        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
+        (total_skunk_score.to_d / analysed_modules_count).to_f.round(2)
       end
 
       def table_options
+        max = sorted_modules.max_by { |a_mod| a_mod.pathname.to_s.length }
+        width = max.pathname.to_s.length + HEADINGS_WITHOUT_FILE_WIDTH
         {
           style: {
-            width: 200
+            width: width
           }
         }
       end
@@ -77,11 +84,11 @@ TEMPL
         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,
-            a_mod.coverage
+            a_mod.cost.round(2),
+            a_mod.coverage.round(2)
           ]
         end
       end