skunk 0.4.2 → 0.5.0

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

@@ -7,24 +7,54 @@ require "skunk"
 require "skunk/rubycritic/analysed_module"
 require "skunk/cli/options"
 require "skunk/cli/command_factory"
+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

@@ -3,17 +3,18 @@
 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
 
@@ -29,10 +30,13 @@ 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

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

@@ -6,7 +6,17 @@ 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/status_reporter.rb

@@ -10,21 +10,23 @@ 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 %>
+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)
 
@@ -41,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
 
@@ -50,21 +53,21 @@ 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
@@ -81,7 +84,7 @@ 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.round(2),

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "net/https"
+require "json"
+
+require "skunk/cli/commands/status_reporter"
+
+module Skunk
+  module Command
+    # Knows how to share status to an API
+    class StatusSharer < Skunk::Command::StatusReporter
+      attr_reader :status_message
+
+      DEFAULT_URL = "https://skunk.fastruby.io"
+      def status_reporter=(status_reporter)
+        self.analysed_modules = status_reporter.analysed_modules
+        self.score = analysed_modules.score
+      end
+
+      def share
+        return "" if not_sharing?
+
+        response = post_payload
+
+        @status_message =
+          if Net::HTTPOK === response
+            data = JSON.parse response.body
+            "Shared at: #{File.join(base_url, data['id'])}"
+          else
+            "Error sharing report: #{response}"
+          end
+      end
+
+      private
+
+      # :reek:UtilityFunction
+      def base_url
+        ENV["SHARE_URL"] || DEFAULT_URL
+      end
+
+      def json_summary
+        result = {
+          total_skunk_score: total_skunk_score,
+          analysed_modules_count: analysed_modules_count,
+          skunk_score_average: skunk_score_average,
+          skunk_version: Skunk::VERSION
+        }
+
+        if worst
+          result[:worst_skunk_score] = {
+            file: worst.pathname.to_s,
+            skunk_score: worst.skunk_score
+          }
+        end
+
+        result
+      end
+
+      def json_results
+        sorted_modules.map(&:to_hash)
+      end
+
+      # :reek:UtilityFunction
+      def not_sharing?
+        ENV["SHARE"] != "true" && ENV["SHARE_URL"].to_s == ""
+      end
+
+      def payload
+        JSON.generate(
+          "entries" => json_results,
+          "summary" => json_summary,
+          "options" => {
+            "compare" => "false"
+          }
+        )
+      end
+
+      # :reek:TooManyStatements
+      def post_payload
+        req = Net::HTTP::Post.new(url)
+        req.body = payload
+
+        http = Net::HTTP.new(url.hostname, url.port)
+        if url.scheme == "https"
+          http.use_ssl = true
+          http.ssl_version = :TLSv1_2
+        end
+
+        http.start do |connection|
+          connection.request req
+        end
+      end
+
+      def url
+        URI(File.join(base_url, "reports"))
+      end
+    end
+  end
+end

data/lib/skunk/cli/options/argv.rb

@@ -9,6 +9,9 @@ module Skunk
       # Extends RubyCritic::Cli::Options::Argv to parse a subset of the
       # parameters accepted by RubyCritic
       class Argv < RubyCritic::Cli::Options::Argv
+        # :reek:Attribute
+        attr_accessor :output_filename
+
         def parse # rubocop:disable Metrics/MethodLength
           parser.new do |opts|
             opts.banner = "Usage: skunk [options] [paths]\n"
@@ -19,6 +22,10 @@ module Skunk
               self.mode = :compare_branches
             end
 
+            opts.on("-o", "--out FILE", "Output report to file") do |filename|
+              self.output_filename = filename
+            end
+
             opts.on_tail("-v", "--version", "Show gem's version") do
               self.mode = :version
             end
@@ -28,6 +35,10 @@ module Skunk
             end
           end.parse!(@argv)
         end
+
+        def to_h
+          super.merge(output_filename: output_filename)
+        end
       end
     end
   end

data/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)
@@ -43,5 +43,25 @@ module RubyCritic
       safe_churn = churn.positive? ? churn : 1
       @churn_times_cost ||= (safe_churn * cost).round(2)
     end
+
+    # Returns a hash with these attributes:
+    #   - file
+    #   - skunk_score
+    #   - churn_times_cost
+    #   - churn
+    #   - cost
+    #   - coverage
+    #
+    # @return [Hash]
+    def to_hash
+      {
+        file: pathname.to_s,
+        skunk_score: skunk_score,
+        churn_times_cost: churn_times_cost,
+        churn: churn,
+        cost: cost.round(2),
+        coverage: coverage.round(2)
+      }
+    end
   end
 end