skunk 0.3.2 → 0.5.1

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

@@ -2,42 +2,64 @@
 
 require "rubycritic/commands/compare"
 require "skunk/rubycritic/analysed_modules_collection"
+require "skunk/cli/commands/output"
+require "skunk/cli/commands/shareable"
+require "skunk/cli/commands/compare_score"
 
 # nodoc #
 module Skunk
-  module Command
-    # Knows how to compare two branches and their stink 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.root = branch_directory(branch)
-      end
+  module Cli
+    module Command
+      # Knows how to compare two branches and their skunk score average
+      class Compare < RubyCritic::Command::Compare
+        include Skunk::Cli::Command::Shareable
 
-      # generate report only for modified files but don't report it
-      def analyse_modified_files
-        modified_files = ::RubyCritic::Config
-                         .feature_branch_collection
-                         .where(::RubyCritic::SourceControlSystem::Git.modified_files)
-        ::RubyCritic::AnalysedModulesCollection.new(modified_files.map(&:path),
-                                                    modified_files)
-        ::RubyCritic::Config.root = "#{::RubyCritic::Config.root}/compare"
-      end
+        def initialize(options)
+          super
+          @options = options
+          @status_reporter = Skunk::Command::StatusReporter.new(options)
+        end
 
-      # 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"
-        File.open(build_details_path, "w") { |file| file.write(details) }
-        puts details
-      end
+        def execute
+          compare_branches
+          status_reporter
+        end
+
+        # 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.skunk_score_average)
+          ::RubyCritic::Config.root = branch_directory(branch)
+        end
+
+        # generate report only for modified files but don't report it
+        def analyse_modified_files
+          modified_files = ::RubyCritic::Config
+                           .feature_branch_collection
+                           .where(::RubyCritic::SourceControlSystem::Git.modified_files)
+          ::RubyCritic::AnalysedModulesCollection.new(modified_files.map(&:path),
+                                                      modified_files)
+          ::RubyCritic::Config.root = "#{::RubyCritic::Config.root}/compare"
+        end
+
+        # create a txt file with the branch score details
+        def build_details
+          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
 
-      def build_details_path
-        "#{::RubyCritic::Config.compare_root_directory}/build_details.txt"
+        def build_details_path
+          "#{::RubyCritic::Config.compare_root_directory}/build_details.txt"
+        end
       end
     end
   end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# nodoc #
+module Skunk
+  module Cli
+    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
+end

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

@@ -6,6 +6,7 @@ require "rubycritic/revision_comparator"
 require "rubycritic/reporter"
 
 require "skunk/cli/commands/base"
+require "skunk/cli/commands/shareable"
 require "skunk/cli/commands/status_reporter"
 
 module Skunk
@@ -14,18 +15,30 @@ module Skunk
       # Default command runs a critique using RubyCritic and uses
       # Skunk::Command::StatusReporter to report status
       class Default < RubyCritic::Command::Default
+        include Skunk::Cli::Command::Shareable
+
         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

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/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/shareable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Skunk
+  module Cli
+    module Command
+      # This is a module that will be used for sharing reports to a server
+      module Shareable
+        # 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
+end

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

@@ -10,19 +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)
 
@@ -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

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

@@ -0,0 +1,99 @@
+# 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
+      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