skunk 0.5.4 → 0.6.0

data/lib/skunk/commands/status_sharer.rb

@@ -23,7 +23,7 @@ module Skunk
         response = post_payload
 
         @status_message =
-          if Net::HTTPOK === response
+          if response.is_a?(Net::HTTPOK)
             data = JSON.parse response.body
             "Shared at: #{File.join(base_url, data['id'])}"
           else
@@ -33,22 +33,22 @@ module Skunk
 
       private
 
-      # :reek:UtilityFunction
       def base_url
-        ENV["SHARE_URL"] || DEFAULT_URL
+        share_url_empty? ? DEFAULT_URL : share_url
       end
 
       def json_summary
         result = {
-          total_skunk_score: total_skunk_score,
-          analysed_modules_count: analysed_modules_count,
-          skunk_score_average: skunk_score_average,
+          total_skunk_score: analysed_modules.skunk_score_total,
+          analysed_modules_count: analysed_modules.analysed_modules_count,
+          skunk_score_average: analysed_modules.skunk_score_average,
           skunk_version: Skunk::VERSION
         }
 
-        if worst
+        if analysed_modules&.worst_module
+          worst = analysed_modules.worst_module
           result[:worst_skunk_score] = {
-            file: worst.pathname.to_s,
+            file: worst.pathname,
             skunk_score: worst.skunk_score
           }
         end
@@ -57,12 +57,26 @@ module Skunk
       end
 
       def json_results
-        sorted_modules.map(&:to_hash)
+        analysed_modules.sorted_modules.map(&:to_hash)
       end
 
       # :reek:UtilityFunction
       def not_sharing?
-        ENV["SHARE"] != "true" && ENV["SHARE_URL"].to_s == ""
+        !share_enabled? && share_url_empty?
+      end
+
+      # @return [Boolean] Check if sharing is enabled via environment variable
+      def share_enabled?
+        ENV["SHARE"] == "true"
+      end
+
+      # @return [Boolean] Check if share URL is empty
+      def share_url_empty?
+        share_url.empty?
+      end
+
+      def share_url
+        @share_url ||= ENV["SHARE_URL"].to_s
       end
 
       def payload
@@ -79,6 +93,7 @@ module Skunk
       def post_payload
         req = Net::HTTP::Post.new(url)
         req.body = payload
+        req.content_type = "application/json"
 
         http = Net::HTTP.new(url.hostname, url.port)
         if url.scheme == "https"

data/lib/skunk/config.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "rubycritic/configuration"
+
+module Skunk
+  # Utility module for format validation
+  module FormatValidator
+    # Supported output formats
+    SUPPORTED_FORMATS = %i[json html console].freeze
+
+    # Check if a format is supported
+    # @param format [Symbol] Format to check
+    # @return [Boolean] True if format is supported
+    def self.supported_format?(format)
+      SUPPORTED_FORMATS.include?(format)
+    end
+
+    # Get all supported formats
+    # @return [Array<Symbol>] All supported formats
+    def self.supported_formats
+      SUPPORTED_FORMATS.dup
+    end
+  end
+
+  # Configuration class for Skunk that supports formats
+  # Similar to RubyCritic::Configuration but focused only on Skunk's needs
+  class Configuration
+    # Default format
+    DEFAULT_FORMAT = :console
+
+    def initialize
+      @formats = [DEFAULT_FORMAT]
+      @root = nil
+    end
+
+    def set(options = {})
+      self.formats = options[:formats] if options.key?(:formats)
+      self.root = options[:root] if options.key?(:root)
+    end
+
+    # Get the configured formats
+    # @return [Array<Symbol>] Array of format symbols
+    attr_reader :formats
+
+    # Set the formats with validation
+    # @param format_list [Array<Symbol>, Symbol] Format(s) to set
+    def formats=(format_list)
+      format_array = Array(format_list)
+      @formats = format_array.select { |format| FormatValidator.supported_format?(format) }
+      @formats = [DEFAULT_FORMAT] if @formats.empty?
+    end
+
+    # Path where reports are written. An explicit value (from --out) wins;
+    # otherwise it follows RubyCritic::Config.root, which RubyCritic sets on
+    # every run, so a stale value from an earlier run is never reused.
+    def root
+      @root || RubyCritic::Config.root || File.expand_path("tmp/rubycritic", Dir.pwd)
+    end
+
+    # @return [Boolean] True when the output path was set explicitly
+    def root_set?
+      !!@root
+    end
+
+    def root=(path)
+      path_str = path.to_s
+      @root = path_str.empty? ? nil : File.expand_path(path_str)
+    end
+
+    # Add a format to the existing list
+    # @param format [Symbol] Format to add
+    def add_format(format)
+      return unless FormatValidator.supported_format?(format)
+
+      @formats << format unless @formats.include?(format)
+    end
+
+    # Remove a format from the list
+    # @param format [Symbol] Format to remove
+    def remove_format(format)
+      @formats.delete(format)
+      @formats = [DEFAULT_FORMAT] if @formats.empty?
+    end
+
+    # Check if a format is supported
+    # @param format [Symbol] Format to check
+    # @return [Boolean] True if format is supported
+    def supported_format?(format)
+      FormatValidator.supported_format?(format)
+    end
+
+    # Get all supported formats
+    # @return [Array<Symbol>] All supported formats
+    def supported_formats
+      FormatValidator.supported_formats
+    end
+
+    # Reset to default configuration
+    def reset
+      @formats = [DEFAULT_FORMAT]
+      @root = nil
+    end
+  end
+
+  # Config module that delegates to Configuration instance
+  # Similar to RubyCritic::Config pattern
+  module Config
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.set(options = {})
+      configuration.set(options)
+    end
+
+    def self.method_missing(method, *args, &block)
+      if configuration.respond_to?(method)
+        configuration.public_send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def self.respond_to_missing?(symbol, include_private = false)
+      configuration.respond_to?(symbol, include_private) || super
+    end
+  end
+end

data/lib/skunk/generators/console/simple.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "erb"
+require "terminal-table"
+
+module Skunk
+  module Generator
+    module Console
+      # Generates a console report for the analysed modules.
+      class Simple
+        def initialize(analysed_modules)
+          @analysed_modules = analysed_modules
+        end
+
+        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 %>
+
+          SkunkScore Total: <%= total_skunk_score %>
+          Modules Analysed: <%= analysed_modules_count %>
+          SkunkScore Average: <%= skunk_score_average %>
+          <% if worst %>Worst SkunkScore: <%= worst.skunk_score %> (<%= worst.pathname %>)<% end %>
+
+          Generated with Skunk v<%= Skunk::VERSION %>
+        TEMPL
+                          )
+
+        def render
+          opts = table_options.merge(headings: HEADINGS, rows: table)
+          _ttable = Terminal::Table.new(opts)
+          TEMPLATE.result(binding)
+        end
+
+        private
+
+        def analysed_modules_count
+          @analysed_modules.analysed_modules_count
+        end
+
+        def worst
+          @analysed_modules.worst_module
+        end
+
+        def sorted_modules
+          @analysed_modules.sorted_modules
+        end
+
+        def total_skunk_score
+          @analysed_modules.skunk_score_total
+        end
+
+        def total_churn_times_cost
+          @analysed_modules.total_churn_times_cost
+        end
+
+        def skunk_score_average
+          @analysed_modules.skunk_score_average
+        end
+
+        def table_options
+          return { style: { width: 100 } } if sorted_modules.empty?
+
+          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: width
+            }
+          }
+        end
+
+        def table
+          @analysed_modules.files_as_hash.map { |file_hash| self.class.format_hash_row(file_hash) }
+        end
+
+        def self.format_hash_row(file_hash)
+          [
+            file_hash[:file],
+            file_hash[:skunk_score],
+            file_hash[:churn_times_cost],
+            file_hash[:churn],
+            file_hash[:cost],
+            file_hash[:coverage]
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/skunk/generators/console_report.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "erb"
+require "terminal-table"
+require "pathname"
+require "fileutils"
+
+require "skunk/generators/console/simple"
+require "skunk/config"
+
+module Skunk
+  module Generator
+    # Generates a console report for the analysed modules.
+    class ConsoleReport
+      FILE_NAME = "skunk_report.txt"
+
+      def initialize(analysed_modules)
+        @analysed_modules = analysed_modules
+      end
+
+      def generate_report
+        content = generator.render
+        puts content
+        write_file(content) if Skunk::Config.root_set?
+      end
+
+      private
+
+      def generator
+        @generator ||= Skunk::Generator::Console::Simple.new(@analysed_modules)
+      end
+
+      # Only written when --out is given, so a plain `skunk` run stays free of filesystem side effects
+      def write_file(content)
+        FileUtils.mkdir_p(file_directory)
+        File.write(file_pathname, content)
+      end
+
+      def file_directory
+        @file_directory ||= Pathname.new(Skunk::Config.root)
+      end
+
+      def file_pathname
+        file_directory.join(FILE_NAME)
+      end
+    end
+  end
+end

data/lib/skunk/generators/html/file_data.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Skunk
+  module Generator
+    module Html
+      # Data object for individual file information in the HTML overview report
+      class FileData
+        attr_reader :file, :skunk_score, :churn_times_cost, :churn, :cost, :coverage
+
+        def initialize(module_data)
+          @file = PathTruncator.truncate(module_data.pathname)
+          @skunk_score = module_data.skunk_score
+          @churn_times_cost = module_data.churn_times_cost
+          @churn = module_data.churn
+          @cost = module_data.cost.round(2)
+          @coverage = module_data.coverage.round(2)
+        end
+      end
+    end
+  end
+end

data/lib/skunk/generators/html/overview.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "rubycritic/generators/html/base"
+
+require "skunk/generators/html/path_truncator"
+require "skunk/generators/html/file_data"
+require "skunk/rubycritic/analysed_modules_collection"
+
+module Skunk
+  module Generator
+    module Html
+      # Generates an HTML overview report for the analysed modules.
+      class Overview < RubyCritic::Generator::Html::Base
+        def self.erb_template(template_path)
+          ERB.new(File.read(File.join(TEMPLATES_DIR, template_path)))
+        end
+
+        TEMPLATES_DIR = File.expand_path("templates", __dir__)
+        TEMPLATE = erb_template("skunk_overview.html.erb")
+
+        def initialize(analysed_modules)
+          @analysed_modules = analysed_modules
+          @generated_at = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+          @skunk_version = Skunk::VERSION
+        end
+
+        def file_name
+          "skunk_report.html"
+        end
+
+        def render
+          TEMPLATE.result(binding)
+        end
+
+        def analysed_modules_count
+          @analysed_modules.analysed_modules_count
+        end
+
+        def skunk_score_total
+          @analysed_modules.skunk_score_total
+        end
+
+        def skunk_score_average
+          @analysed_modules.skunk_score_average
+        end
+
+        def files
+          @files ||= @analysed_modules.sorted_modules.map do |module_data|
+            FileData.new(module_data)
+          end
+        end
+
+        private
+
+        def root_directory
+          @root_directory ||= Pathname.new(Skunk::Config.root)
+        end
+      end
+    end
+  end
+end

data/lib/skunk/generators/html/path_truncator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Skunk
+  module Generator
+    module Html
+      # Utility class for truncating file paths to show only the relevant project structure
+      class PathTruncator
+        attr_reader :file_path
+
+        # Common project folder names to truncate from
+        PROJECT_FOLDERS = %w[app lib src test spec features db].freeze
+
+        # Truncates a file path to show only the relevant project structure
+        # starting from the first project folder found
+        #
+        # @param file_path [String] The full file path to truncate
+        # @return [String] The truncated path starting from the project folder
+        # :reek:NilCheck
+        def self.truncate(file_path)
+          return file_path if file_path.nil?
+
+          new(file_path).truncate
+        end
+
+        def initialize(file_path)
+          @file_path = file_path.to_s
+        end
+
+        # :reek:TooManyStatements
+        def truncate
+          return file_path if file_path.empty?
+
+          path_parts = file_path.split("/")
+          folder_index = path_parts.find_index do |part|
+            PROJECT_FOLDERS.include?(part)
+          end
+
+          if folder_index
+            # rubocop:disable Style/SlicingWithRange
+            path_parts[folder_index..-1].join("/")
+            # rubocop:enable Style/SlicingWithRange
+          else
+            file_path
+          end
+        end
+      end
+    end
+  end
+end