rubycritic-simplecov 4.1.0

data/lib/rubycritic/analysers/smells/reek.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'rubycritic/analysers/helpers/reek'
+require 'rubycritic/core/smell'
+require 'rubycritic/colorize'
+
+module RubyCritic
+  module Analyser
+    class ReekSmells
+      include Colorize
+      def initialize(analysed_modules)
+        @analysed_modules = analysed_modules
+      end
+
+      def run
+        @analysed_modules.each do |analysed_module|
+          add_smells_to(analysed_module)
+          print green '.'
+        end
+        puts ''
+      end
+
+      def to_s
+        'reek smells'
+      end
+
+      private
+
+      def add_smells_to(analysed_module)
+        Reek.new(analysed_module.pathname).smells.each do |smell|
+          analysed_module.smells << create_smell(smell)
+        end
+      end
+
+      def create_smell(smell)
+        Smell.new(
+          locations: smell_locations(smell.source, smell.lines),
+          context: smell.context,
+          message: smell.message,
+          type: smell.smell_type,
+          analyser: 'reek',
+          cost: 0
+        )
+      end
+
+      def smell_locations(file_path, file_lines)
+        file_lines.uniq.map do |file_line|
+          Location.new(file_path, file_line)
+        end.sort
+      end
+    end
+  end
+end

data/lib/rubycritic/analysers_runner.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'rubycritic/core/analysed_modules_collection'
+require 'rubycritic/analysers/smells/flay'
+require 'rubycritic/analysers/smells/flog'
+require 'rubycritic/analysers/smells/reek'
+require 'rubycritic/analysers/complexity'
+require 'rubycritic/analysers/churn'
+require 'rubycritic/analysers/attributes'
+require 'rubycritic/analysers/coverage'
+
+module RubyCritic
+  class AnalysersRunner
+    ANALYSERS = [
+      Analyser::FlaySmells,
+      Analyser::FlogSmells,
+      Analyser::ReekSmells,
+      Analyser::Complexity,
+      Analyser::Attributes,
+      Analyser::Churn,
+      Analyser::Coverage
+    ].freeze
+
+    def initialize(paths)
+      @paths = paths
+    end
+
+    def run
+      ANALYSERS.each do |analyser_class|
+        analyser_instance = analyser_class.new(analysed_modules)
+        puts "running #{analyser_instance}"
+        analyser_instance.run
+      end
+      analysed_modules
+    end
+
+    def analysed_modules
+      @analysed_modules ||= AnalysedModulesCollection.new(@paths)
+    end
+  end
+end

data/lib/rubycritic/analysis_summary.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubyCritic
+  class AnalysisSummary
+    def self.generate(analysed_modules)
+      new(analysed_modules).generate
+    end
+
+    def initialize(analysed_modules)
+      @analysed_modules = analysed_modules
+    end
+
+    def generate
+      %w[A B C D F].each_with_object({}) do |rating, summary|
+        summary[rating] = generate_for(rating)
+      end
+    end
+
+    private
+
+    attr_reader :analysed_modules, :modules
+
+    def generate_for(rating)
+      @modules = analysed_modules.for_rating(rating)
+      {
+        files: modules.count,
+        churns: churns,
+        smells: smells
+      }
+    end
+
+    def churns
+      modules.inject(0) { |acc, elem| acc + elem.churn }
+    end
+
+    def smells
+      modules.inject(0) { |acc, elem| acc + elem.smells.count }
+    end
+  end
+end

data/lib/rubycritic/browser.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'launchy'
+
+module RubyCritic
+  class Browser
+    attr_reader :report_path
+
+    def initialize(report_path)
+      @report_path = report_path
+    end
+
+    def open
+      Launchy.open(report_path) do |exception|
+        puts "Attempted to open #{report_path} and failed because #{exception}"
+      end
+    end
+  end
+end

data/lib/rubycritic/cli/application.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rubycritic'
+require 'rubycritic/browser'
+require 'rubycritic/cli/options'
+require 'rubycritic/command_factory'
+
+module RubyCritic
+  module Cli
+    class Application
+      STATUS_SUCCESS = 0
+      STATUS_ERROR   = 1
+
+      def initialize(argv)
+        @options = Options.new(argv)
+      end
+
+      def execute
+        parsed_options = @options.parse.to_h
+
+        reporter = RubyCritic::CommandFactory.create(parsed_options).execute
+        print(reporter.status_message)
+        reporter.status
+      rescue OptionParser::InvalidOption => error
+        warn "Error: #{error}"
+        STATUS_ERROR
+      end
+
+      def print(message)
+        $stdout.puts message
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module RubyCritic
+  module Cli
+    class Options
+      # rubocop:disable Metrics/ClassLength
+      class Argv
+        def initialize(argv)
+          @argv = argv
+          self.parser = OptionParser.new
+        end
+
+        # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        def parse
+          parser.new do |opts|
+            opts.banner = 'Usage: rubycritic [options] [paths]'
+
+            opts.on('-p', '--path [PATH]', 'Set path where report will be saved (tmp/rubycritic by default)') do |path|
+              @root = path
+            end
+
+            opts.on('-b', '--branch BRANCH', 'Set branch to compare') do |branch|
+              self.base_branch = String(branch)
+              set_current_branch
+              self.mode = :compare_branches
+            end
+
+            opts.on(
+              '-t',
+              '--maximum-decrease [MAX_DECREASE]',
+              'Set a threshold for score difference between two branches (works only with -b)'
+            ) do |threshold_score|
+              self.threshold_score = Integer(threshold_score)
+            end
+
+            formats = []
+            self.formats = formats
+            opts.on(
+              '-f', '--format [FORMAT]',
+              %i[html json console lint],
+              'Report smells in the given format:',
+              '  html (default; will open in a browser)',
+              '  json',
+              '  console',
+              '  lint',
+              'Multiple formats are supported.'
+            ) do |format|
+              formats << format
+            end
+
+            formatters = []
+            self.formatters = formatters
+            opts.on(
+              '--custom-format [REQUIREPATH]:[CLASSNAME]|[CLASSNAME]',
+              'Instantiate a given class as formatter and call report for reporting.',
+              'Two ways are possible to load the formatter.',
+              'If the class is not autorequired the REQUIREPATH can be given together',
+              'with the CLASSNAME to be loaded seperated by a :.',
+              'Example: rubycritic/markdown/reporter.rb:RubyCritic::MarkDown::Reporter',
+              'or if the file is already required the CLASSNAME is enough',
+              'Example: RubyCritic::MarkDown::Reporter',
+              'Multiple formatters are supported.'
+            ) do |formatter|
+              formatters << formatter
+            end
+
+            opts.on('-s', '--minimum-score [MIN_SCORE]', 'Set a minimum score') do |min_score|
+              self.minimum_score = Float(min_score)
+            end
+
+            opts.on('-m', '--mode-ci [BASE_BRANCH]',
+                    'Use CI mode (faster, analyses diffs w.r.t base_branch (default: master))') do |branch|
+              self.base_branch = branch || 'master'
+              set_current_branch
+              self.mode = :ci
+            end
+
+            opts.on('--deduplicate-symlinks', 'De-duplicate symlinks based on their final target') do
+              self.deduplicate_symlinks = true
+            end
+
+            opts.on('--suppress-ratings', 'Suppress letter ratings') do
+              self.suppress_ratings = true
+            end
+
+            opts.on('--no-browser', 'Do not open html report with browser') do
+              self.no_browser = true
+            end
+
+            opts.on_tail('-v', '--version', "Show gem's version") do
+              self.mode = :version
+            end
+
+            opts.on_tail('-h', '--help', 'Show this message') do
+              self.mode = :help
+            end
+          end.parse!(@argv)
+        end
+
+        def to_h
+          {
+            mode: mode,
+            root: root,
+            formats: formats,
+            formatters: formatters,
+            deduplicate_symlinks: deduplicate_symlinks,
+            paths: paths,
+            suppress_ratings: suppress_ratings,
+            help_text: parser.help,
+            minimum_score: minimum_score,
+            no_browser: no_browser,
+            base_branch: base_branch,
+            feature_branch: feature_branch,
+            threshold_score: threshold_score
+          }
+        end
+        # rubocop:enable Metrics/MethodLength,Metrics/AbcSize
+
+        private
+
+        attr_accessor :mode, :root, :formats, :formatters, :deduplicate_symlinks,
+                      :suppress_ratings, :minimum_score, :no_browser,
+                      :parser, :base_branch, :feature_branch, :threshold_score
+        def paths
+          @argv unless @argv.empty?
+        end
+
+        def set_current_branch
+          self.feature_branch = SourceControlSystem::Git.current_branch
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

data/lib/rubycritic/cli/options/file.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module RubyCritic
+  module Cli
+    class Options
+      class File
+        attr_reader :filename, :options
+
+        def initialize(filename = './.rubycritic.yml')
+          @filename = filename
+          @options = {}
+        end
+
+        def parse
+          @options = YAML.load_file(filename) if ::File.file?(filename)
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def to_h
+          {
+            mode: mode,
+            root: root,
+            formats: formats,
+            deduplicate_symlinks: deduplicate_symlinks,
+            paths: paths,
+            suppress_ratings: suppress_ratings,
+            minimum_score: minimum_score,
+            no_browser: no_browser,
+            base_branch: base_branch,
+            feature_branch: feature_branch,
+            threshold_score: threshold_score
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        def base_branch
+          return options.dig('mode_ci', 'branch') || 'master' if options.dig('mode_ci', 'enabled').to_s == 'true'
+
+          options['branch']
+        end
+
+        def mode
+          if options.dig('mode_ci', 'enabled').to_s == 'true'
+            :ci
+          elsif base_branch
+            :compare_branches
+          end
+        end
+
+        def feature_branch
+          SourceControlSystem::Git.current_branch if base_branch
+        end
+
+        def root
+          options['path']
+        end
+
+        def threshold_score
+          options['threshold_score']
+        end
+
+        def deduplicate_symlinks
+          value_for(options['deduplicate_symlinks'])
+        end
+
+        def suppress_ratings
+          value_for(options['suppress_ratings'])
+        end
+
+        def no_browser
+          value_for(options['no_browser'])
+        end
+
+        def formats
+          formats = Array(options['formats'])
+          formats.select do |format|
+            %w[html json console lint].include?(format)
+          end.map(&:to_sym)
+        end
+
+        def minimum_score
+          options['minimum_score']
+        end
+
+        def paths
+          options['paths']
+        end
+
+        def value_for(value)
+          value = value.to_s
+          value == 'true' unless value.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rubycritic/cli/options.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'rubycritic/cli/options/argv'
+require 'rubycritic/cli/options/file'
+
+module RubyCritic
+  module Cli
+    class Options
+      attr_reader :argv_options, :file_options
+
+      def initialize(argv)
+        @argv_options = Argv.new(argv)
+        @file_options = File.new
+      end
+
+      def parse
+        argv_options.parse
+        file_options.parse
+        self
+      end
+
+      # :reek:NilCheck
+      def to_h
+        file_hash = file_options.to_h
+        argv_hash = argv_options.to_h
+
+        file_hash.merge(argv_hash) do |_, file_option, argv_option|
+          Array(argv_option).empty? ? file_option : argv_option
+        end
+      end
+    end
+  end
+end

data/lib/rubycritic/colorize.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyCritic
+  module Colorize
+    def colorize(text, color_code)
+      "\e[#{color_code}m#{text}\e[0m"
+    end
+
+    def red(text)
+      colorize(text, 31)
+    end
+
+    def green(text)
+      colorize(text, 32)
+    end
+  end
+end

data/lib/rubycritic/command_factory.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rubycritic/configuration'
+
+module RubyCritic
+  class CommandFactory
+    COMMAND_CLASS_MODES = %i[version help ci compare default].freeze
+
+    def self.create(options = {})
+      Config.set(options)
+      command_class(Config.mode).new(options)
+    end
+
+    def self.command_class(mode)
+      mode = mode.to_s.split('_').first.to_sym
+      if COMMAND_CLASS_MODES.include? mode
+        require "rubycritic/commands/#{mode}"
+        Command.const_get(mode.capitalize)
+      else
+        require 'rubycritic/commands/default'
+        Command::Default
+      end
+    end
+  end
+end

data/lib/rubycritic/commands/base.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rubycritic/commands/status_reporter'
+
+module RubyCritic
+  module Command
+    class Base
+      def initialize(options)
+        @options = options
+        @status_reporter = RubyCritic::Command::StatusReporter.new(@options)
+      end
+
+      def execute
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rubycritic/commands/ci.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rubycritic/source_control_systems/base'
+require 'rubycritic/analysers_runner'
+require 'rubycritic/reporter'
+require 'rubycritic/commands/default'
+require 'rubycritic/commands/compare'
+
+module RubyCritic
+  module Command
+    class Ci < Compare
+    end
+  end
+end

data/lib/rubycritic/commands/compare.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'rubycritic/source_control_systems/base'
+require 'rubycritic/analysers_runner'
+require 'rubycritic/revision_comparator'
+require 'rubycritic/reporter'
+require 'rubycritic/commands/base'
+require 'rubycritic/commands/default'
+require 'rubycritic/commands/utils/build_number_file'
+
+module RubyCritic
+  module Command
+    class Compare < Default
+      def initialize(options)
+        super
+        @build_number = 0
+      end
+
+      def execute
+        compare_branches
+        status_reporter.score = Config.feature_branch_score
+        status_reporter
+      end
+
+      private
+
+      attr_reader :paths, :status_reporter
+
+      def compare_branches
+        @build_number = Utils::BuildNumberFile.new.update_build_number
+        set_root_paths
+        original_no_browser_config = Config.no_browser
+        Config.no_browser = true
+        analyse_branch(:base_branch)
+        analyse_branch(:feature_branch)
+        Config.no_browser = original_no_browser_config
+        analyse_modified_files
+        compare_code_quality
+      end
+
+      def set_root_paths
+        Config.base_root_directory = Pathname.new(branch_directory(:base_branch))
+        Config.feature_root_directory = Pathname.new(branch_directory(:feature_branch))
+        Config.compare_root_directory = Pathname.new("#{Config.root}/compare")
+      end
+
+      # switch branch and analyse files
+      def analyse_branch(branch)
+        SourceControlSystem::Git.switch_branch(Config.send(branch))
+        critic = critique(branch)
+        Config.send(:"#{branch}_score=", critic.score)
+        Config.root = branch_directory(branch)
+        report(critic)
+      end
+
+      # generate report only for modified files
+      def analyse_modified_files
+        modified_files = Config.feature_branch_collection.where(SourceControlSystem::Git.modified_files)
+        analysed_modules = AnalysedModulesCollection.new(modified_files.map(&:path), modified_files)
+        Config.root = "#{Config.root}/compare"
+        report(analysed_modules)
+      end
+
+      def compare_code_quality
+        build_details
+        compare_threshold
+      end
+
+      # mark build as failed if the diff b/w the score of
+      # two branches is greater than threshold value
+      def compare_threshold
+        return unless mark_build_fail?
+
+        print("Threshold: #{Config.threshold_score}\n")
+        print("Difference: #{(Config.base_branch_score - Config.feature_branch_score).abs}\n")
+        abort('The score difference between the two branches is over the threshold.')
+      end
+
+      def mark_build_fail?
+        Config.threshold_score >= 0 && threshold_reached?
+      end
+
+      def threshold_reached?
+        (Config.base_branch_score - Config.feature_branch_score) > Config.threshold_score
+      end
+
+      def branch_directory(branch)
+        "#{Config.root}/compare/#{Config.send(branch)}"
+      end
+
+      # create a txt file with the branch score details
+      def build_details
+        details = "Base branch (#{Config.base_branch}) score: #{Config.base_branch_score} \n"\
+                  "Feature branch (#{Config.feature_branch}) score: #{Config.feature_branch_score} \n"
+        File.open("#{Config.compare_root_directory}/build_details.txt", 'w') { |file| file.write(details) }
+      end
+
+      # store the analysed moduled collection based on the branch
+      def critique(branch)
+        module_collection = AnalysersRunner.new(paths).run
+        Config.send(:"#{branch}_collection=", module_collection)
+        RevisionComparator.new(paths).statuses = module_collection
+      end
+    end
+  end
+end

data/lib/rubycritic/commands/default.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rubycritic/source_control_systems/base'
+require 'rubycritic/analysers_runner'
+require 'rubycritic/revision_comparator'
+require 'rubycritic/reporter'
+require 'rubycritic/commands/base'
+
+module RubyCritic
+  module Command
+    class Default < Base
+      def initialize(options)
+        super
+        @paths = options[:paths] || ['.']
+        Config.source_control_system = SourceControlSystem::Base.create
+      end
+
+      def execute
+        report(critique)
+        status_reporter
+      end
+
+      def critique
+        analysed_modules = AnalysersRunner.new(paths).run
+        RevisionComparator.new(paths).statuses = analysed_modules
+      end
+
+      def report(analysed_modules)
+        Reporter.generate_report(analysed_modules)
+        status_reporter.score = analysed_modules.score
+      end
+
+      private
+
+      attr_reader :paths, :status_reporter
+    end
+  end
+end