rubocop 0.88.0 → 0.91.1

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

@@ -29,8 +29,8 @@ module RuboCop
       #     HEREDOC
       #   end               # 5 points
       #
-      class MethodLength < Cop
-        include TooManyLines
+      class MethodLength < Base
+        include CodeLength
 
         LABEL = 'Method'
 

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

@@ -29,8 +29,8 @@ module RuboCop
       #     HEREDOC
       #   end                 # 5 points
       #
-      class ModuleLength < Cop
-        include TooManyLines
+      class ModuleLength < Base
+        include CodeLength
 
         def on_module(node)
           check_code_length(node)

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

@@ -6,7 +6,7 @@ module RuboCop
       # 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
+      class ParameterLists < Base
         include ConfigurableMax
 
         MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
@@ -18,7 +18,7 @@ module RuboCop
 
           return if argument_to_lambda_or_proc?(node)
 
-          add_offense(node) do
+          add_offense(node, message: format(MSG, max: max_params, count: args_count(node))) do
             self.max = count
           end
         end
@@ -29,10 +29,6 @@ module RuboCop
           ^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

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

@@ -26,13 +26,11 @@ module RuboCop
       #       do_something until a && b   # 2
       #     end                           # ===
       #   end                             # 7 complexity points
-      class PerceivedComplexity < Cop
-        include MethodComplexity
-
+      class PerceivedComplexity < CyclomaticComplexity
         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
+
+        COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze
 
         private
 
@@ -42,17 +40,18 @@ module RuboCop
             # 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.
+            nb_branches = node.when_branches.length + (node.else_branch ? 1 : 0)
             if node.condition.nil?
-              node.when_branches.length
+              nb_branches
             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
+              (0.8 + 0.2 * nb_branches).round
             end
           when :if
             node.else? && !node.elsif? ? 2 : 1
           else
-            1
+            super
           end
         end
       end

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

@@ -11,32 +11,41 @@ module RuboCop
         # We separate the *calculator* from the *cop* so that the calculation,
         # the formula itself, is easier to test.
         class AbcSizeCalculator
+          include IteratingBlock
+          include RepeatedCsendDiscount
+
           # > 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
+          BRANCH_NODES = %i[send csend yield].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 - %i[block block_pass]).freeze
+          CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 
           def self.calculate(node)
             new(node).calculate
           end
 
+          # TODO: move to rubocop-ast
+          ARGUMENT_TYPES = %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg].freeze
+
+          private_constant :BRANCH_NODES, :CONDITION_NODES, :ARGUMENT_TYPES
+
           def initialize(node)
             @assignment = 0
             @branch = 0
             @condition = 0
             @node = node
+            reset_repeated_csend
           end
 
           def calculate
             @node.each_node do |child|
-              if child.assignment?
-                @assignment += 1
-              elsif branch?(child)
+              @assignment += 1 if assignment?(child)
+
+              if branch?(child)
                 evaluate_branch_nodes(child)
               elsif condition?(child)
                 evaluate_condition_node(child)
@@ -54,6 +63,7 @@ module RuboCop
               @condition += 1
             else
               @branch += 1
+              @condition += 1 if node.csend_type? && !discount_for_repeated_csend?(node)
             end
           end
 
@@ -70,11 +80,55 @@ module RuboCop
 
           private
 
+          def assignment?(node)
+            return compound_assignment(node) if node.masgn_type? || node.shorthand_asgn?
+
+            node.for_type? ||
+              (node.respond_to?(:setter_method?) && node.setter_method?) ||
+              simple_assignment?(node) ||
+              argument?(node)
+          end
+
+          def compound_assignment(node)
+            # Methods setter can not be detected for multiple assignments
+            # and shorthand assigns, so we'll count them here instead
+            children = node.masgn_type? ? node.children[0].children : node.children
+
+            will_be_miscounted = children.count do |child|
+              child.respond_to?(:setter_method?) &&
+                !child.setter_method?
+            end
+            @assignment += will_be_miscounted
+
+            false
+          end
+
+          def simple_assignment?(node)
+            if !node.equals_asgn?
+              false
+            elsif node.lvasgn_type?
+              reset_on_lvasgn(node)
+              capturing_variable?(node.children.first)
+            else
+              true
+            end
+          end
+
+          def capturing_variable?(name)
+            name && !/^_/.match?(name)
+          end
+
           def branch?(node)
             BRANCH_NODES.include?(node.type)
           end
 
+          def argument?(node)
+            ARGUMENT_TYPES.include?(node.type) && capturing_variable?(node.children.first)
+          end
+
           def condition?(node)
+            return false if iterating_block?(node) == false
+
             CONDITION_NODES.include?(node.type)
           end
         end

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

@@ -10,10 +10,12 @@ module RuboCop
           include Util
 
           FOLDABLE_TYPES = %i[array hash heredoc].freeze
-          CLASSISH_TYPES = %i[class module].freeze
+          CLASSLIKE_TYPES = %i[class module].freeze
+          private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
 
-          def initialize(node, count_comments: false, foldable_types: [])
+          def initialize(node, processed_source, count_comments: false, foldable_types: [])
             @node = node
+            @processed_source = processed_source
             @count_comments = count_comments
             @foldable_checks = build_foldable_checks(foldable_types)
             @foldable_types = normalize_foldable_types(foldable_types)
@@ -21,13 +23,11 @@ module RuboCop
 
           def calculate
             length = code_length(@node)
+            return length if @foldable_types.empty?
 
-            each_top_level_descendant(@node, *@foldable_types, *CLASSISH_TYPES) do |descendant|
-              descendant_length = code_length(descendant)
-
-              if classlike_node?(descendant)
-                length -= (descendant_length + 2)
-              elsif foldable_node?(descendant)
+            each_top_level_descendant(@node, @foldable_types) do |descendant|
+              if foldable_node?(descendant)
+                descendant_length = code_length(descendant)
                 length = length - descendant_length + 1
               end
             end
@@ -37,14 +37,6 @@ module RuboCop
 
           private
 
-          def_node_matcher :class_definition?, <<~PATTERN
-            (casgn nil? _ (block (send (const nil? :Class) :new) ...))
-          PATTERN
-
-          def_node_matcher :module_definition?, <<~PATTERN
-            (casgn nil? _ (block (send (const nil? :Module) :new) ...))
-          PATTERN
-
           def build_foldable_checks(types)
             types.map do |type|
               case type
@@ -67,35 +59,72 @@ module RuboCop
           end
 
           def code_length(node)
-            return heredoc_length(node) if heredoc_node?(node)
+            if classlike_node?(node)
+              classlike_code_length(node)
+            elsif heredoc_node?(node)
+              heredoc_length(node)
+            else
+              body = extract_body(node)
+              return 0 unless body
 
-            body = extract_body(node)
-            lines = body&.source&.lines || []
-            lines.count { |line| !irrelevant_line?(line) }
+              body.source.each_line.count { |line| !irrelevant_line?(line) }
+            end
           end
 
           def heredoc_node?(node)
             node.respond_to?(:heredoc?) && node.heredoc?
           end
 
+          def classlike_code_length(node)
+            return 0 if namespace_module?(node)
+
+            body_line_numbers = line_range(node).to_a[1...-1]
+
+            target_line_numbers = body_line_numbers -
+                                  line_numbers_of_inner_nodes(node, :module, :class)
+
+            target_line_numbers.reduce(0) do |length, line_number|
+              source_line = @processed_source[line_number]
+              next length if irrelevant_line?(source_line)
+
+              length + 1
+            end
+          end
+
+          def namespace_module?(node)
+            classlike_node?(node.body)
+          end
+
+          def line_numbers_of_inner_nodes(node, *types)
+            line_numbers = Set.new
+
+            node.each_descendant(*types) do |inner_node|
+              line_range = line_range(inner_node)
+              line_numbers.merge(line_range)
+            end
+
+            line_numbers.to_a
+          end
+
           def heredoc_length(node)
             lines = node.loc.heredoc_body.source.lines
             lines.count { |line| !irrelevant_line?(line) } + 2
           end
 
-          def each_top_level_descendant(node, *types, &block)
+          def each_top_level_descendant(node, types, &block)
             node.each_child_node do |child|
+              next if classlike_node?(child)
+
               if types.include?(child.type)
                 yield child
               else
-                each_top_level_descendant(child, *types, &block)
+                each_top_level_descendant(child, types, &block)
               end
             end
           end
 
           def classlike_node?(node)
-            CLASSISH_TYPES.include?(node.type) ||
-              (node.casgn_type? && (class_definition?(node) || module_definition?(node)))
+            CLASSLIKE_TYPES.include?(node.type)
           end
 
           def foldable_node?(node)

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # @api private
+        #
+        # Helps to calculate code length for the provided node.
+        module RepeatedCsendDiscount
+          def reset_repeated_csend
+            @repeated_csend = {}
+          end
+
+          def discount_for_repeated_csend?(csend_node)
+            receiver = csend_node.receiver
+
+            return false unless receiver.lvar_type?
+
+            var_name = receiver.children.first
+            seen = @repeated_csend.fetch(var_name) do
+              @repeated_csend[var_name] = csend_node
+              return false
+            end
+
+            !seen.equal?(csend_node)
+          end
+
+          def reset_on_lvasgn(node)
+            var_name = node.children.first
+            @repeated_csend.delete(var_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/migration/department_name.rb

@@ -5,8 +5,9 @@ module RuboCop
     module Migration
       # Check that cop names in rubocop:disable comments are given with
       # department name.
-      class DepartmentName < Cop
+      class DepartmentName < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Department name is missing.'
 
@@ -18,8 +19,8 @@ module RuboCop
         # `DepartmentName/CopName` or` all`.
         DISABLING_COPS_CONTENT_TOKEN = %r{[A-z]+/[A-z]+|all}.freeze
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
+        def on_new_investigation
+          processed_source.comments.each do |comment|
             next if comment.text !~ DISABLE_COMMENT_FORMAT
 
             offset = Regexp.last_match(1).length
@@ -38,18 +39,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(range)
-          shall_warn = false
-          cop_name = range.source
-          qualified_cop_name = Cop.registry.qualified_cop_name(cop_name,
-                                                               nil, shall_warn)
-          unless qualified_cop_name.include?('/')
-            qualified_cop_name = qualified_legacy_cop_name(cop_name)
-          end
-
-          ->(corrector) { corrector.replace(range, qualified_cop_name) }
-        end
-
         private
 
         def disable_comment_offset
@@ -60,7 +49,16 @@ module RuboCop
           start = comment.location.expression.begin_pos + offset
           range = range_between(start, start + name.length)
 
-          add_offense(range, location: range)
+          add_offense(range) do |corrector|
+            cop_name = range.source
+            qualified_cop_name = Registry.global.qualified_cop_name(cop_name, nil, warn: false)
+
+            unless qualified_cop_name.include?('/')
+              qualified_cop_name = qualified_legacy_cop_name(cop_name)
+            end
+
+            corrector.replace(range, qualified_cop_name)
+          end
         end
 
         def valid_content_token?(content_token)

data/lib/rubocop/cop/mixin/alignment.rb

@@ -42,6 +42,7 @@ module RuboCop
         end
       end
 
+      # @api private
       def each_bad_alignment(items, base_column)
         prev_line = -1
         items.each do |current|
@@ -55,17 +56,20 @@ module RuboCop
         end
       end
 
+      # @api public
       def display_column(range)
         line = processed_source.lines[range.line - 1]
         Unicode::DisplayWidth.of(line[0, range.column])
       end
 
+      # @api public
       def within?(inner, outer)
         inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
       end
 
+      # @deprecated Use processed_source.comment_at_line(line)
       def end_of_line_comment(line)
-        processed_source.find_comment { |c| c.loc.line == line }
+        processed_source.line_with_comment?(line)
       end
     end
   end