rbhint 0.8.5.rc1

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks that the ABC size of methods is not higher than the
+      # configured maximum. The ABC size is based on assignments, branches
+      # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
+      # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
+      class AbcSize < Cop
+        include MethodComplexity
+
+        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
+              '[%<abc_vector>s %<complexity>.4g/%<max>.4g]'
+
+        private
+
+        def complexity(node)
+          Utils::AbcSizeCalculator.calculate(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/block_length.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks if the length of a block exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      # The cop can be configured to ignore blocks passed to certain methods.
+      class BlockLength < Cop
+        include TooManyLines
+
+        LABEL = 'Block'
+
+        def on_block(node)
+          return if excluded_method?(node)
+          return if node.class_constructor?
+
+          check_code_length(node)
+        end
+
+        private
+
+        def excluded_method?(node)
+          node_receiver = node.receiver&.source&.gsub(/\s+/, '')
+          node_method = String(node.method_name)
+
+          excluded_methods.any? do |config|
+            receiver, method = config.split('.')
+
+            unless method
+              method = receiver
+              receiver = node_receiver
+            end
+
+            method == node_method && receiver == node_receiver
+          end
+        end
+
+        def excluded_methods
+          cop_config['ExcludedMethods'] || []
+        end
+
+        def cop_label
+          LABEL
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/block_nesting.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks for excessive nesting of conditional and looping
+      # constructs.
+      #
+      # You can configure if blocks are considered using the `CountBlocks`
+      # option. When set to `false` (the default) blocks are not counted
+      # towards the nesting level. Set to `true` to count blocks as well.
+      #
+      # The maximum level of nesting allowed is configurable.
+      class BlockNesting < Cop
+        include ConfigurableMax
+
+        NESTING_BLOCKS = %i[
+          case if while while_post
+          until until_post for resbody
+        ].freeze
+
+        def investigate(processed_source)
+          return if processed_source.blank?
+
+          max = cop_config['Max']
+          check_nesting_level(processed_source.ast, max, 0)
+        end
+
+        private
+
+        def check_nesting_level(node, max, current_level)
+          if consider_node?(node)
+            current_level += 1 unless node.if_type? && node.elsif?
+            if current_level > max
+              self.max = current_level
+              unless part_of_ignored_node?(node)
+                add_offense(node, message: message(max)) do
+                  ignore_node(node)
+                end
+              end
+            end
+          end
+
+          node.each_child_node do |child_node|
+            check_nesting_level(child_node, max, current_level)
+          end
+        end
+
+        def consider_node?(node)
+          return true if NESTING_BLOCKS.include?(node.type)
+
+          count_blocks? && node.block_type?
+        end
+
+        def message(max)
+          "Avoid more than #{max} levels of block nesting."
+        end
+
+        def count_blocks?
+          cop_config['CountBlocks']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/class_length.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks if the length a class exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      class ClassLength < Cop
+        include ClassishLength
+
+        def on_class(node)
+          check_code_length(node)
+        end
+
+        def on_casgn(node)
+          class_definition?(node) do
+            check_code_length(node)
+          end
+        end
+
+        private
+
+        def_node_matcher :class_definition?, <<~PATTERN
+          (casgn nil? _ (block (send (const nil? :Class) :new) ...))
+        PATTERN
+
+        def message(length, max_length)
+          format('Class has too many lines. [%<length>d/%<max>d]',
+                 length: length,
+                 max: max_length)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/cyclomatic_complexity.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks that the cyclomatic complexity of methods is not higher
+      # than the configured maximum. The cyclomatic complexity is the number of
+      # linearly independent paths through a method. The algorithm counts
+      # decision points and adds one.
+      #
+      # An if statement (or unless or ?:) increases the complexity by one. An
+      # else branch does not, since it doesn't add a decision point. The &&
+      # operator (or keyword and) can be converted to a nested if statement,
+      # and ||/or is shorthand for a sequence of ifs, so they also add one.
+      # Loops can be said to have an exit condition, so they add one.
+      class CyclomaticComplexity < Cop
+        include MethodComplexity
+
+        MSG = 'Cyclomatic complexity for %<method>s is too high. ' \
+              '[%<complexity>d/%<max>d]'
+        COUNTED_NODES = %i[if while until for
+                           rescue when and or].freeze
+
+        private
+
+        def complexity_score_for(_node)
+          1
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/method_length.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks if the length of a method exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      class MethodLength < Cop
+        include TooManyLines
+
+        LABEL = 'Method'
+
+        def on_def(node)
+          excluded_methods = cop_config['ExcludedMethods']
+          return if excluded_methods.include?(String(node.method_name))
+
+          check_code_length(node)
+        end
+        alias on_defs on_def
+
+        def on_block(node)
+          return unless node.send_node.method?(:define_method)
+
+          check_code_length(node)
+        end
+
+        private
+
+        def cop_label
+          LABEL
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/module_length.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks if the length a module exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      class ModuleLength < Cop
+        include ClassishLength
+
+        def on_module(node)
+          check_code_length(node)
+        end
+
+        def on_casgn(node)
+          module_definition?(node) do
+            check_code_length(node)
+          end
+        end
+
+        private
+
+        def_node_matcher :module_definition?, <<~PATTERN
+          (casgn nil? _ (block (send (const nil? :Module) :new) ...))
+        PATTERN
+
+        def message(length, max_length)
+          format('Module has too many lines. [%<length>d/%<max>d]',
+                 length: length,
+                 max: max_length)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks for methods with too many parameters.
+      # The maximum number of parameters is configurable.
+      # Keyword arguments can optionally be excluded from the total count.
+      class ParameterLists < Cop
+        include ConfigurableMax
+
+        MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
+              '[%<count>d/%<max>d]'
+
+        def on_args(node)
+          count = args_count(node)
+          return unless count > max_params
+
+          return if argument_to_lambda_or_proc?(node)
+
+          add_offense(node) do
+            self.max = count
+          end
+        end
+
+        private
+
+        def_node_matcher :argument_to_lambda_or_proc?, <<~PATTERN
+          ^lambda_or_proc?
+        PATTERN
+
+        def message(node)
+          format(MSG, max: max_params, count: args_count(node))
+        end
+
+        def args_count(node)
+          if count_keyword_args?
+            node.children.size
+          else
+            node.children.count { |a| !%i[kwoptarg kwarg].include?(a.type) }
+          end
+        end
+
+        def max_params
+          cop_config['Max']
+        end
+
+        def count_keyword_args?
+          cop_config['CountKeywordArgs']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop tries to produce a complexity score that's a measure of the
+      # complexity the reader experiences when looking at a method. For that
+      # reason it considers `when` nodes as something that doesn't add as much
+      # complexity as an `if` or a `&&`. Except if it's one of those special
+      # `case`/`when` constructs where there's no expression after `case`. Then
+      # the cop treats it as an `if`/`elsif`/`elsif`... and lets all the `when`
+      # nodes count. In contrast to the CyclomaticComplexity cop, this cop
+      # considers `else` nodes as adding complexity.
+      #
+      # @example
+      #
+      #   def my_method                   # 1
+      #     if cond                       # 1
+      #       case var                    # 2 (0.8 + 4 * 0.2, rounded)
+      #       when 1 then func_one
+      #       when 2 then func_two
+      #       when 3 then func_three
+      #       when 4..10 then func_other
+      #       end
+      #     else                          # 1
+      #       do_something until a && b   # 2
+      #     end                           # ===
+      #   end                             # 7 complexity points
+      class PerceivedComplexity < Cop
+        include MethodComplexity
+
+        MSG = 'Perceived complexity for %<method>s is too high. ' \
+              '[%<complexity>d/%<max>d]'
+        COUNTED_NODES = %i[if case while until
+                           for rescue and or].freeze
+
+        private
+
+        def complexity_score_for(node)
+          case node.type
+          when :case
+            # If cond is nil, that means each when has an expression that
+            # evaluates to true or false. It's just an alternative to
+            # if/elsif/elsif... so the when nodes count.
+            if node.condition.nil?
+              node.when_branches.length
+            else
+              # Otherwise, the case node gets 0.8 complexity points and each
+              # when gets 0.2.
+              (0.8 + 0.2 * node.when_branches.length).round
+            end
+          when :if
+            node.else? && !node.elsif? ? 2 : 1
+          else
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # > ABC is .. a software size metric .. computed by counting the number
+        # > of assignments, branches and conditions for a section of code.
+        # > http://c2.com/cgi/wiki?AbcMetric
+        #
+        # We separate the *calculator* from the *cop* so that the calculation,
+        # the formula itself, is easier to test.
+        class AbcSizeCalculator
+          # > Branch -- an explicit forward program branch out of scope -- a
+          # > function call, class method call ..
+          # > http://c2.com/cgi/wiki?AbcMetric
+          BRANCH_NODES = %i[send csend].freeze
+
+          # > Condition -- a logical/Boolean test, == != <= >= < > else case
+          # > default try catch ? and unary conditionals.
+          # > http://c2.com/cgi/wiki?AbcMetric
+          CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
+
+          def self.calculate(node)
+            new(node).calculate
+          end
+
+          def initialize(node)
+            @assignment = 0
+            @branch = 0
+            @condition = 0
+            @node = node
+          end
+
+          def calculate
+            @node.each_node do |child|
+              if child.assignment?
+                @assignment += 1
+              elsif branch?(child)
+                evaluate_branch_nodes(child)
+              elsif condition?(child)
+                evaluate_condition_node(child)
+              end
+            end
+
+            [
+              Math.sqrt(@assignment**2 + @branch**2 + @condition**2).round(2),
+              "<#{@assignment}, #{@branch}, #{@condition}>"
+            ]
+          end
+
+          def evaluate_branch_nodes(node)
+            if node.comparison_method?
+              @condition += 1
+            else
+              @branch += 1
+            end
+          end
+
+          def evaluate_condition_node(node)
+            @condition += 1 if else_branch?(node)
+            @condition += 1
+          end
+
+          def else_branch?(node)
+            %i[case if].include?(node.type) &&
+              node.else? &&
+              node.loc.else.is?('else')
+          end
+
+          private
+
+          def branch?(node)
+            BRANCH_NODES.include?(node.type)
+          end
+
+          def condition?(node)
+            CONDITION_NODES.include?(node.type)
+          end
+        end
+      end
+    end
+  end
+end