rubycritic-simplecov 4.1.0

data/lib/rubycritic/commands/help.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rubycritic/commands/base'
+
+module RubyCritic
+  module Command
+    class Help < Base
+      def execute
+        puts options[:help_text]
+        status_reporter
+      end
+
+      private
+
+      attr_reader :options, :status_reporter
+    end
+  end
+end

data/lib/rubycritic/commands/status_reporter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyCritic
+  module Command
+    class StatusReporter
+      attr_reader :status, :status_message, :score
+      SUCCESS = 0
+      SCORE_BELOW_MINIMUM = 1
+
+      def initialize(options)
+        @options = options
+        @status = SUCCESS
+      end
+
+      def score=(input_score)
+        @score = input_score.round(2)
+        update_status
+      end
+
+      private
+
+      def update_status
+        @status = current_status
+        update_status_message
+      end
+
+      def current_status
+        satisfy_minimum_score_rule ? SUCCESS : SCORE_BELOW_MINIMUM
+      end
+
+      def satisfy_minimum_score_rule
+        score >= @options[:minimum_score].to_f
+      end
+
+      def update_status_message
+        case @status
+        when SUCCESS
+          @status_message = "Score: #{score}"
+        when SCORE_BELOW_MINIMUM
+          @status_message = "Score (#{score}) is below the minimum #{@options[:minimum_score]}"
+        end
+      end
+    end
+  end
+end

data/lib/rubycritic/commands/utils/build_number_file.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyCritic
+  module Command
+    module Utils
+      class BuildNumberFile
+        attr_reader :file, :build_number
+
+        def initialize
+          open_build_number_file
+        end
+
+        # keep track of the number of builds and
+        # use this build number to create separate directory for each build
+        def update_build_number
+          @build_number = file.read.to_i + 1
+          write_build_number
+          build_number
+        end
+
+        def write_build_number
+          file.rewind
+          file.write(build_number)
+          file.close
+        end
+
+        def open_build_number_file
+          root = Config.root
+          FileUtils.mkdir_p(root) unless File.directory?(root)
+          location = "#{root}/build_number.txt"
+          File.new(location, 'a') unless File.exist?(location)
+          @file = File.open(location, 'r+')
+        end
+      end
+    end
+  end
+end

data/lib/rubycritic/commands/version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rubycritic/version'
+require 'rubycritic/commands/base'
+
+module RubyCritic
+  module Command
+    class Version < Base
+      attr_reader :status_reporter
+      def execute
+        puts "RubyCritic #{VERSION}"
+        status_reporter
+      end
+    end
+  end
+end

data/lib/rubycritic/configuration.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'rubycritic/source_control_systems/base'
+
+module RubyCritic
+  class Configuration
+    attr_reader :root
+    attr_accessor :source_control_system, :mode, :formats, :formatters, :deduplicate_symlinks,
+                  :suppress_ratings, :open_with, :no_browser, :base_branch,
+                  :feature_branch, :base_branch_score, :feature_branch_score,
+                  :base_root_directory, :feature_root_directory,
+                  :compare_root_directory, :threshold_score, :base_branch_collection,
+                  :feature_branch_collection
+
+    def set(options)
+      self.mode = options[:mode] || :default
+      self.root = options[:root] || 'tmp/rubycritic'
+      self.deduplicate_symlinks = options[:deduplicate_symlinks]
+      self.suppress_ratings = options[:suppress_ratings]
+      self.open_with = options[:open_with]
+      self.no_browser = options[:no_browser]
+      self.base_branch = options[:base_branch]
+      self.feature_branch = options[:feature_branch]
+      self.threshold_score = options[:threshold_score].to_i
+      setup_formats(options)
+    end
+
+    def setup_formats(options)
+      formats = options[:formats].to_a
+      self.formats = formats.empty? ? [:html] : formats
+      self.formatters = options[:formatters] || []
+    end
+
+    def root=(path)
+      @root = File.expand_path(path)
+    end
+
+    def source_control_present?
+      source_control_system &&
+        !source_control_system.is_a?(SourceControlSystem::Double)
+    end
+  end
+
+  module Config
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.set(options = {})
+      configuration.set(options)
+    end
+
+    def self.compare_branches_mode?
+      %i[compare_branches ci].include?(Config.mode)
+    end
+
+    def self.build_mode?
+      !Config.no_browser && %i[compare_branches ci].include?(Config.mode)
+    end
+
+    def self.method_missing(method, *args, &block)
+      configuration.public_send(method, *args, &block)
+    end
+
+    def self.respond_to_missing?(symbol, include_all = false)
+      configuration.respond_to_missing?(symbol) || super
+    end
+  end
+end

data/lib/rubycritic/core/analysed_module.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'virtus'
+require 'rubycritic/core/rating'
+
+module RubyCritic
+  class AnalysedModule
+    include Virtus.model
+
+    # Complexity is reduced by a factor of 25 when calculating cost
+    COMPLEXITY_FACTOR = 25.0
+
+    attribute :coverage
+    attribute :name
+    attribute :smells_count
+    attribute :file_location
+    attribute :file_name
+    attribute :line_count
+    attribute :pathname
+    attribute :smells, Array, default: []
+    attribute :churn
+    attribute :committed_at
+    attribute :complexity, Float, default: Float::INFINITY
+    attribute :duplication, Integer, default: 0
+    attribute :methods_count
+
+    def path
+      @path ||= pathname.to_s
+    end
+
+    def file_location
+      pathname.dirname
+    end
+
+    def file_name
+      pathname.basename
+    end
+
+    def line_count
+      File.read(path).each_line.count
+    end
+
+    def cost
+      @cost ||= smells.map(&:cost).inject(0.0, :+) +
+                (complexity / COMPLEXITY_FACTOR)
+    end
+
+    def coverage_rating
+      @coverage_rating ||= Rating.from_cost(100 - coverage)
+    end
+
+    def rating
+      @rating ||= Rating.from_cost(cost)
+    end
+
+    def complexity_per_method
+      if methods_count.zero?
+        'N/A'
+      else
+        complexity.fdiv(methods_count).round(1)
+      end
+    end
+
+    def smells_count
+      smells.count
+    end
+
+    def smells?
+      !smells.empty?
+    end
+
+    def smells_at_location(location)
+      smells.select { |smell| smell.at_location?(location) }
+    end
+
+    def <=>(other)
+      [rating.to_s, name] <=> [other.rating.to_s, other.name]
+    end
+
+    def to_h
+      {
+        name: name, path: path, smells: smells,
+        churn: churn, committed_at: committed_at, complexity: complexity,
+        duplication: duplication, methods_count: methods_count, cost: cost,
+        rating: rating
+      }
+    end
+
+    def to_json(*options)
+      to_h.to_json(*options)
+    end
+  end
+end

data/lib/rubycritic/core/analysed_modules_collection.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'rubycritic/source_locator'
+require 'rubycritic/core/analysed_module'
+
+module RubyCritic
+  class AnalysedModulesCollection
+    include Enumerable
+
+    # Limit used to prevent very bad modules to have excessive impact in the
+    # overall result. See #limited_cost_for
+    COST_LIMIT = 32.0
+    # Score goes from 0 (worst) to 100 (perfect)
+    MAX_SCORE = 100.0
+    # Projects with an average cost of 16 (or above) will score 0, since 16
+    # is where the worst possible rating (F) starts
+    ZERO_SCORE_COST = 16.0
+    COST_MULTIPLIER = MAX_SCORE / ZERO_SCORE_COST
+
+    def initialize(paths, modules = nil)
+      @modules = SourceLocator.new(paths).pathnames.map do |pathname|
+        if modules
+          analysed_module = modules.find { |mod| mod.pathname == pathname }
+          build_analysed_module(analysed_module)
+        else
+          AnalysedModule.new(pathname: pathname)
+        end
+      end
+    end
+
+    def each(&block)
+      @modules.each(&block)
+    end
+
+    def where(module_paths)
+      @modules.find_all { |mod| module_paths.include? mod.path }
+    end
+
+    def find(module_path)
+      @modules.find { |mod| mod.pathname == module_path }
+    end
+
+    def to_json(*options)
+      @modules.to_json(*options)
+    end
+
+    def score
+      if @modules.any?
+        (MAX_SCORE - average_limited_cost * COST_MULTIPLIER).round(2)
+      else
+        0.0
+      end
+    end
+
+    def summary
+      AnalysisSummary.generate(self)
+    end
+
+    def for_rating(rating)
+      find_all { |mod| mod.rating.to_s == rating }
+    end
+
+    private
+
+    def average_limited_cost
+      [average_cost, ZERO_SCORE_COST].min
+    end
+
+    def average_cost
+      num_modules = @modules.size
+      if num_modules.positive?
+        map { |mod| limited_cost_for(mod) }.reduce(:+) / num_modules.to_f
+      else
+        0.0
+      end
+    end
+
+    def limited_cost_for(mod)
+      [mod.cost, COST_LIMIT].min
+    end
+
+    def build_analysed_module(analysed_module)
+      AnalysedModule.new(
+        pathname: analysed_module.pathname,
+        name: analysed_module.name,
+        smells: analysed_module.smells,
+        churn: analysed_module.churn,
+        committed_at: analysed_module.committed_at,
+        complexity: analysed_module.complexity,
+        duplication: analysed_module.duplication,
+        methods_count: analysed_module.methods_count
+      )
+    end
+  end
+end

data/lib/rubycritic/core/location.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RubyCritic
+  class Location
+    attr_reader :pathname, :line
+
+    def initialize(path, line)
+      @pathname = Pathname.new(path)
+      @line = line.to_i
+    end
+
+    def file_name
+      @pathname.basename.sub_ext('').to_s
+    end
+
+    def to_s
+      "#{pathname}:#{line}"
+    end
+
+    def to_h
+      {
+        path: pathname.to_s,
+        line: line
+      }
+    end
+
+    def to_json(*options)
+      to_h.to_json(*options)
+    end
+
+    def ==(other)
+      state == other.state
+    end
+
+    def <=>(other)
+      state <=> other.state
+    end
+
+    protected
+
+    def state
+      [@pathname, @line]
+    end
+  end
+end

data/lib/rubycritic/core/rating.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyCritic
+  class Rating
+    def self.from_cost(cost)
+      if    cost <= 2  then new('A')
+      elsif cost <= 4  then new('B')
+      elsif cost <= 8  then new('C')
+      elsif cost <= 16 then new('D')
+      else new('F')
+      end
+    end
+
+    def initialize(letter)
+      @letter = letter
+    end
+
+    def to_s
+      @letter
+    end
+
+    def to_h
+      @letter
+    end
+
+    def to_json(*options)
+      to_h.to_json(*options)
+    end
+  end
+end

data/lib/rubycritic/core/smell.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'virtus'
+require 'rubycritic/core/location'
+
+module RubyCritic
+  class Smell
+    include Virtus.model
+
+    attribute :context
+    attribute :cost
+    attribute :locations, Array, default: []
+    attribute :message
+    attribute :score
+    attribute :status
+    attribute :type
+    attribute :analyser
+
+    FLAY_DOCS_URL = 'http://docs.seattlerb.org/flay/'.freeze
+    FLOG_DOCS_URL = 'http://docs.seattlerb.org/flog/'.freeze
+
+    def at_location?(other_location)
+      locations.any? { |location| location == other_location }
+    end
+
+    def multiple_locations?
+      locations.length > 1
+    end
+
+    def ==(other)
+      state == other.state
+    end
+    alias eql? ==
+
+    def to_s
+      "(#{type}) #{context} #{message}"
+    end
+
+    def to_h
+      {
+        context: context,
+        cost: cost,
+        locations: locations,
+        message: message,
+        score: score,
+        status: status,
+        type: type
+      }
+    end
+
+    def to_json(*options)
+      to_h.to_json(*options)
+    end
+
+    def doc_url
+      case analyser
+      when 'reek'
+        "https://github.com/troessner/reek/blob/master/docs/#{dasherized_type}.md"
+      when 'flay'
+        FLAY_DOCS_URL
+      when 'flog'
+        FLOG_DOCS_URL
+      else
+        raise "No documentation URL set for analyser '#{analyser}' smells"
+      end
+    end
+
+    def hash
+      state.hash
+    end
+
+    protected
+
+    def state
+      [context, message, score, type]
+    end
+
+    private
+
+    def dasherized_type
+      type.gsub(/(?<!^)([A-Z])/, '-\1')
+    end
+  end
+end

data/lib/rubycritic/generators/console_report.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rubycritic/generators/text/list'
+
+module RubyCritic
+  module Generator
+    class ConsoleReport
+      def initialize(analysed_modules)
+        @analysed_modules = analysed_modules
+      end
+
+      def generate_report
+        reports = @analysed_modules.sort.map do |mod|
+          Text::List.new(mod).render
+        end
+        puts reports.join("\n")
+      end
+    end
+  end
+end