rubycritic-simplecov 4.1.0

data/ROADMAP.md

@@ -0,0 +1,56 @@
+These are more nice-to-haves than promises. We can always dream. But this is what we hope to improve in RubyCritic:
+
+- [ ] Explain every single code smell. This includes the "Churn vs Complexity" scatter plot and other graphs that may be implemented.
+
+- [ ] Provide suggestions to fix every code smell. Figure out how to present them in the UI.
+
+- [ ] Improve how modules are graded. Each module is awarded a score, depending on:
+
+  * Its complexity, based off of this [post by Jake Scruggs](http://jakescruggs.blogspot.pt/2008/08/whats-good-flog-score.html), creator of the MetricFu gem. For every 25 points of complexity (as calculated by Flog), the score increases by 1.
+
+  * Its duplication mass, based off of observations of a few Code Climate repos. For every 25 points of mass (as calculated by Flay), the score increases by 1.
+
+  Finally, this score is translated to a grade like [this](https://github.com/whitesmith/rubycritic/blob/43005e7b76dd0c648c7715133e42afdd6ea9a065/lib/rubycritic/core/rating.rb), based off of a [Code Climate blog post](http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/#value-objects).
+
+- [ ] Implement a project rating, ala Code Climate.
+
+- [ ] Explain ratings. What's the difference between an A and a B? Bryan Helmkamp, the creator of Code Climate, wrote [a great essay on the subject](https://gist.github.com/brynary/21369b5892525e1bd102). #63
+
+- [ ] Explore alternative ratings. GPA and A-F grades are quite US centric. #50
+
+- [ ] Make the gem configurable using a dotfile like .rubycritic.yml. #30
+      Here are some possible settings:
+
+  - [ ] Quiet mode. As of right now, any Ruby code that is unparsable will be reported three times (one time by Flog, another by Flay and another by Reek). Only Flog implements a quiet option, which means we have to implement that quiet option on Flay and on Reek before we can add it to RubyCritic. Or we could just do `$stderr = StringIO.new`... I wonder if that's really really smart or really really stupid.
+
+  - [ ] Verbose mode. #61
+
+  - [ ] Ignoring/excluding files. #11
+
+  - [ ] Allow configuring date range of Churn calculation. #37 Right now, they are limited to the last year. #39
+
+- [ ] Highlight blocks of duplicated code instead of just the start of the block. This will probably require rewriting Flay with [parser](https://github.com/whitequark/parser) instead of ruby_parser.
+
+- [ ] Integrate other gems, like:
+
+  - [ ] [Simplecov](https://github.com/colszowka/simplecov) to provide code coverage
+
+  - [ ] [Rubocop](https://github.com/bbatsov/rubocop/) to provide style issues
+
+  - [ ] [Brakeman](https://github.com/presidentbeef/brakeman) to provide security issues (Rails-only feature)
+
+  - [ ] [Rails Best Practices](https://github.com/railsbp/rails_best_practices) to provide Rails smells (Rails-only feature) #14
+
+  - [ ] [SandiMeter](https://github.com/makaroni4/sandi_meter) #15
+
+- [ ] Improve UI.
+
+  - [ ] Make it beautiful.
+
+  - [ ] Figure out where the "suggestions to fix code smells" should be presented.
+
+  - [ ] Create some kind of toggle option between various types of issues. Just like we can toggle between "Smells" and "Coverage" in Code Climate:
+
+    ![Code Climate Toggle Option](https://camo.githubusercontent.com/d97fc62dae6ebef1f35bda91942d4a6bacc445b2/687474703a2f2f626c6f672e636f6465636c696d6174652e636f6d2f696d616765732f706f7374732f74657374696e672e676966)
+
+    Having an option to toggle between "Smells", "Security" (Brakeman) and "Style" (Rubocop) would be great. But that's already assuming we can integrate those gems into RubyCritic.

data/Rakefile

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rubocop/rake_task'
+require 'cucumber/rake/task'
+require 'reek/rake/task'
+require 'rubycritic/rake_task'
+
+Rake::TestTask.new do |task|
+  task.libs.push 'lib'
+  task.libs.push 'test'
+  task.pattern = 'test/**/*_test.rb'
+end
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = 'features --format progress --color'
+end
+
+RuboCop::RakeTask.new
+
+Reek::Rake::Task.new
+
+RubyCritic::RakeTask.new do |task|
+  task.paths = FileList['lib/**/*.rb']
+end
+
+task default: %i[test features reek rubocop]

data/bin/rubycritic

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Always look in the lib directory of this gem
+# first when searching the load path
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'rubycritic/cli/application'
+
+exit RubyCritic::Cli::Application.new(ARGV).execute

data/lib/rubycritic/analysers/attributes.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rubycritic/analysers/helpers/methods_counter'
+require 'rubycritic/analysers/helpers/modules_locator'
+require 'rubycritic/colorize'
+
+module RubyCritic
+  module Analyser
+    class Attributes
+      include Colorize
+      def initialize(analysed_modules)
+        @analysed_modules = analysed_modules
+      end
+
+      def run
+        @analysed_modules.each do |analysed_module|
+          analysed_module.methods_count = MethodsCounter.new(analysed_module).count
+          analysed_module.name = ModulesLocator.new(analysed_module).first_name
+          print green '.'
+        end
+        puts ''
+      end
+
+      def to_s
+        'attributes'
+      end
+    end
+  end
+end

data/lib/rubycritic/analysers/churn.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'rubycritic/colorize'
+
+module RubyCritic
+  module Analyser
+    class Churn
+      include Colorize
+      attr_writer :source_control_system
+
+      def initialize(analysed_modules)
+        @analysed_modules = analysed_modules
+        @source_control_system = Config.source_control_system
+      end
+
+      def run
+        @analysed_modules.each do |analysed_module|
+          analysed_module.churn = @source_control_system.revisions_count(analysed_module.path)
+          analysed_module.committed_at = @source_control_system.date_of_last_commit(analysed_module.path)
+          print green '.'
+        end
+        puts ''
+      end
+
+      def to_s
+        'churn'
+      end
+    end
+  end
+end

data/lib/rubycritic/analysers/complexity.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'rubycritic/analysers/helpers/flog'
+require 'rubycritic/colorize'
+
+module RubyCritic
+  module Analyser
+    class Complexity
+      include Colorize
+      def initialize(analysed_modules)
+        @flog = Flog.new
+        @analysed_modules = analysed_modules
+      end
+
+      def run
+        @analysed_modules.each do |analysed_module|
+          @flog.reset
+          @flog.flog(analysed_module.path)
+          analysed_module.complexity = @flog.total_score.round(2)
+          print green '.'
+        end
+        puts ''
+      end
+
+      def to_s
+        'complexity'
+      end
+    end
+  end
+end

data/lib/rubycritic/analysers/coverage.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'rubycritic/colorize'
+require 'json'
+require 'simplecov'
+
+module RubyCritic
+  module Analyser
+    class Coverage
+      include Colorize
+
+      def initialize(analysed_modules)
+        @analysed_modules = analysed_modules
+        @result = results.first
+      end
+
+      def run
+        @analysed_modules.each do |analysed_module|
+          analysed_module.coverage = find_coverage_percentage(analysed_module)
+          print green '.'
+        end
+        puts ''
+      end
+
+      def to_s
+        'simple_cov'
+      end
+
+      private
+
+      def find_coverage_percentage(analysed_module)
+        source_file = find_source_file(analysed_module)
+
+        return 0 unless source_file
+
+        source_file.covered_percent
+      end
+
+      def find_source_file(analysed_module)
+        return unless @result
+
+        needle = File.join(SimpleCov.root, analysed_module.path)
+
+        @result.source_files.detect { |file| file.filename == needle }
+      end
+
+      # The path to the .resultset.json cache file
+      def resultset_path
+        File.join(SimpleCov.coverage_path, '.resultset.json')
+      end
+
+      def resultset_writelock
+        File.join(SimpleCov.coverage_path, '.resultset.json.lock')
+      end
+
+      # Loads the cached resultset from JSON and returns it as a Hash,
+      # caching it for subsequent accesses.
+      def resultset
+        @resultset ||= begin
+          if (data = stored_data)
+            begin
+              JSON.parse(data) || {}
+            rescue JSON::ParserError => err
+              puts "Error: Loading .resultset.json: #{err.message}"
+              {}
+            end
+          else
+            {}
+          end
+        end
+      end
+
+      # Returns the contents of the resultset cache as a string or if the file is missing or empty nil
+      def stored_data
+        synchronize_resultset do
+          return unless File.exist?(resultset_path)
+
+          return unless (data = File.read(resultset_path))
+
+          return if data.length < 2
+
+          data
+        end
+      end
+
+      # Ensure only one process is reading or writing the resultset at any
+      # given time
+      def synchronize_resultset
+        # make it reentrant
+        return yield if @resultset_locked == true
+
+        return yield unless File.exist?(resultset_writelock)
+
+        begin
+          @resultset_locked = true
+          File.open(resultset_writelock, 'w+') do |file|
+            file.flock(File::LOCK_EX)
+            yield
+          end
+        ensure
+          @resultset_locked = false
+        end
+      end
+
+      # Gets the resultset hash and re-creates all included instances
+      # of SimpleCov::Result from that.
+      # All results that are above the SimpleCov.merge_timeout will be
+      # dropped. Returns an array of SimpleCov::Result items.
+      def results
+        array = []
+        resultset.each do |command_name, data|
+          array << ::SimpleCov::Result.from_hash(command_name => data)
+        end
+        array
+      end
+    end
+  end
+end

data/lib/rubycritic/analysers/helpers/ast_node.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Parser
+  module AST
+    class Node
+      MODULE_TYPES = %i[module class].freeze
+
+      def count_nodes_of_type(*types)
+        count = 0
+        recursive_children do |child|
+          count += 1 if types.include?(child.type)
+        end
+        count
+      end
+
+      def recursive_children
+        children.each do |child|
+          next unless child.is_a?(Parser::AST::Node)
+
+          yield child
+          child.recursive_children { |grand_child| yield grand_child }
+        end
+      end
+
+      def module_names
+        ast_node_children = children.select do |child|
+          child.is_a?(Parser::AST::Node)
+        end
+
+        children_modules = ast_node_children.flat_map(&:module_names)
+
+        if MODULE_TYPES.include?(type)
+          module_names_with_children children_modules
+        else
+          children_modules
+        end
+      end
+
+      private
+
+      def module_names_with_children(children_modules)
+        if children_modules.empty?
+          [module_name]
+        else
+          children_modules.map do |children_module|
+            "#{module_name}::#{children_module}"
+          end
+        end
+      end
+
+      def module_name
+        name_segments = []
+        current_node = children[0]
+        while current_node
+          name_segments.unshift(current_node.children[1])
+          current_node = current_node.children[0]
+        end
+        name_segments.join('::')
+      end
+    end
+  end
+end
+
+module RubyCritic
+  module AST
+    class EmptyNode
+      def count_nodes_of_type(*)
+        0
+      end
+
+      def module_names
+        []
+      end
+    end
+  end
+end

data/lib/rubycritic/analysers/helpers/flay.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'flay'
+
+module RubyCritic
+  class Flay < ::Flay
+    def initialize(paths)
+      super()
+      process(*paths)
+      analyze
+    end
+  end
+end

data/lib/rubycritic/analysers/helpers/flog.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'flog'
+
+module RubyCritic
+  class Flog < ::Flog
+    DEFAULT_OPTIONS = {
+      all: true,
+      continue: true,
+      methods: true
+    }.freeze
+
+    def initialize
+      super(DEFAULT_OPTIONS)
+    end
+  end
+end

data/lib/rubycritic/analysers/helpers/methods_counter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rubycritic/analysers/helpers/parser'
+
+module RubyCritic
+  class MethodsCounter
+    def initialize(analysed_module)
+      @analysed_module = analysed_module
+    end
+
+    def count
+      node.count_nodes_of_type(:def, :defs)
+    end
+
+    private
+
+    def node
+      Parser.parse(content)
+    end
+
+    def content
+      File.read(@analysed_module.path)
+    end
+  end
+end

data/lib/rubycritic/analysers/helpers/modules_locator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'rubycritic/analysers/helpers/parser'
+
+module RubyCritic
+  class ModulesLocator
+    def initialize(analysed_module)
+      @analysed_module = analysed_module
+    end
+
+    def first_name
+      names.first
+    end
+
+    def names
+      names = node.module_names
+      if names.empty?
+        name_from_path
+      else
+        names
+      end
+    end
+
+    private
+
+    def node
+      Parser.parse(content)
+    end
+
+    def content
+      File.read(@analysed_module.path)
+    end
+
+    def name_from_path
+      [file_name.split('_').map(&:capitalize).join]
+    end
+
+    def file_name
+      @analysed_module.pathname.basename.sub_ext('').to_s
+    end
+  end
+end

data/lib/rubycritic/analysers/helpers/parser.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+require 'rubycritic/analysers/helpers/ast_node'
+
+module RubyCritic
+  module Parser
+    def self.parse(content)
+      ::Parser::CurrentRuby.parse(content) || AST::EmptyNode.new
+    rescue ::Parser::SyntaxError
+      AST::EmptyNode.new
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'reek'
+
+module RubyCritic
+  class Reek < ::Reek::Examiner
+    def initialize(analysed_module)
+      super(analysed_module, configuration: ::Reek::Configuration::AppConfiguration.from_default_path)
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'rubycritic/analysers/helpers/flay'
+require 'rubycritic/core/smell'
+require 'rubycritic/colorize'
+
+module RubyCritic
+  module Analyser
+    class FlaySmells
+      include Colorize
+      def initialize(analysed_modules)
+        @analysed_modules = paths_to_analysed_modules(analysed_modules)
+        @flay = Flay.new(@analysed_modules.keys)
+      end
+
+      def run
+        @flay.hashes.each do |structural_hash, nodes|
+          analyze_modules(structural_hash, nodes)
+          print green '.'
+        end
+        puts ''
+      end
+
+      def to_s
+        'flay smells'
+      end
+
+      private
+
+      def paths_to_analysed_modules(analysed_modules)
+        paths = {}
+        analysed_modules.each do |analysed_module|
+          paths[analysed_module.path] = analysed_module
+        end
+        paths
+      end
+
+      def create_smell(structural_hash, nodes)
+        mass = @flay.masses[structural_hash]
+        Smell.new(
+          locations: smell_locations(nodes),
+          context: similarity(structural_hash),
+          message: "found in #{nodes.size} nodes",
+          score: mass,
+          type: 'DuplicateCode',
+          analyser: 'flay',
+          cost: cost(mass)
+        )
+      end
+
+      def smell_locations(nodes)
+        nodes.map do |node|
+          Location.new(node.file, node.line)
+        end.sort
+      end
+
+      def similarity(structural_hash)
+        if @flay.identical[structural_hash]
+          'Identical code'
+        else
+          'Similar code'
+        end
+      end
+
+      def cost(mass)
+        mass / 25
+      end
+
+      def analyze_modules(structural_hash, nodes)
+        nodes.map(&:file).uniq.each do |file|
+          @analysed_modules[file].smells << create_smell(structural_hash, nodes)
+        end
+        nodes.each do |node|
+          @analysed_modules[node.file].duplication += node.mass
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'rubycritic/analysers/helpers/flog'
+require 'rubycritic/core/smell'
+require 'rubycritic/colorize'
+
+module RubyCritic
+  module Analyser
+    class FlogSmells
+      include Colorize
+      HIGH_COMPLEXITY_SCORE_THRESHOLD = 25
+      VERY_HIGH_COMPLEXITY_SCORE_THRESHOLD = 60
+
+      def initialize(analysed_modules)
+        @flog = Flog.new
+        @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
+        'flog smells'
+      end
+
+      private
+
+      def add_smells_to(analysed_module)
+        @flog.reset
+        @flog.flog(analysed_module.path)
+        @flog.each_by_score do |class_method, original_score|
+          score = original_score.round
+          analysed_module.smells << create_smell(class_method, score) if score >= HIGH_COMPLEXITY_SCORE_THRESHOLD
+        end
+      end
+
+      def create_smell(context, score)
+        Smell.new(
+          locations: smell_locations(context),
+          context: context,
+          message: "has a flog score of #{score}",
+          score: score,
+          type: type(score),
+          analyser: 'flog',
+          cost: 0
+        )
+      end
+
+      def smell_locations(context)
+        line = @flog.method_locations[context]
+        file_path, file_line = line.split(':')
+        [Location.new(file_path, file_line)]
+      end
+
+      def type(score)
+        if score >= VERY_HIGH_COMPLEXITY_SCORE_THRESHOLD
+          'VeryHighComplexity'
+        else
+          'HighComplexity'
+        end
+      end
+    end
+  end
+end