rubocop 0.88.0 → 0.89.0

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -124,8 +124,9 @@ module RuboCop
       #
       #     delegate :method_a, to: :method_b
       #   end
-      class UselessAccessModifier < Cop
+      class UselessAccessModifier < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Useless `%<current>s` access modifier.'
 
@@ -147,17 +148,13 @@ module RuboCop
           check_node(node.children[1]) # singleton class body
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            range = range_by_whole_lines(
-              node.source_range, include_final_newline: true
-            )
+        private
 
-            corrector.remove(range)
-          end
-        end
+        def autocorrect(corrector, node)
+          range = range_by_whole_lines(node.source_range, include_final_newline: true)
 
-        private
+          corrector.remove(range)
+        end
 
         def_node_matcher :static_method_definition?, <<~PATTERN
           {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
@@ -181,7 +178,9 @@ module RuboCop
           if node.begin_type?
             check_scope(node)
           elsif node.send_type? && node.bare_access_modifier?
-            add_offense(node, message: format(MSG, current: node.method_name))
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
@@ -192,8 +191,11 @@ module RuboCop
 
         def check_scope(node)
           cur_vis, unused = check_child_nodes(node, nil, :public)
+          return unless unused
 
-          add_offense(unused, message: format(MSG, current: cur_vis)) if unused
+          add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+            autocorrect(corrector, unused)
+          end
         end
 
         def check_child_nodes(node, unused, cur_vis)
@@ -216,7 +218,9 @@ module RuboCop
           if node.bare_access_modifier?
             check_new_visibility(node, unused, node.method_name, cur_vis)
           elsif node.method?(:private_class_method) && !node.arguments?
-            add_offense(node, message: format(MSG, current: node.method_name))
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
             [cur_vis, unused]
           end
         end
@@ -224,10 +228,16 @@ module RuboCop
         def check_new_visibility(node, unused, new_vis, cur_vis)
           # does this modifier just repeat the existing visibility?
           if new_vis == cur_vis
-            add_offense(node, message: format(MSG, current: cur_vis))
+            add_offense(node, message: format(MSG, current: cur_vis)) do |corrector|
+              autocorrect(corrector, node)
+            end
           else
             # was the previous modifier never applied to any defs?
-            add_offense(unused, message: format(MSG, current: cur_vis)) if unused
+            if unused
+              add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+                autocorrect(corrector, unused)
+              end
+            end
             # once we have already warned about a certain modifier, don't
             # warn again even if it is never applied to any method defs
             unused = node

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -30,11 +30,11 @@ module RuboCop
       #     some_var = 1
       #     do_something(some_var)
       #   end
-      class UselessAssignment < Cop
+      class UselessAssignment < Base
         MSG = 'Useless assignment to variable - `%<variable>s`.'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
@@ -57,7 +57,7 @@ module RuboCop
                          assignment.node.loc.name
                        end
 
-            add_offense(nil, location: location, message: message)
+            add_offense(location, message: message)
           end
         end
 

data/lib/rubocop/cop/lint/useless_else_without_rescue.rb

@@ -29,24 +29,15 @@ module RuboCop
       #   else
       #     do_something_else
       #   end
-      class UselessElseWithoutRescue < Cop
-        include ParserDiagnostic
-
+      class UselessElseWithoutRescue < Base
         MSG = '`else` without `rescue` is useless.'
 
-        private
-
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :useless_else
-        end
-
-        def find_offense_node_by(diagnostic)
-          # TODO: When implementing auto-correction, this method should return
-          # an offense node passed as first argument of `add_offense` method.
-        end
+        def on_new_investigation
+          processed_source.diagnostics.each do |diagnostic|
+            next unless diagnostic.reason == :useless_else
 
-        def alternative_message(_diagnostic)
-          MSG
+            add_offense(diagnostic.location, severity: diagnostic.level)
+          end
         end
       end
     end

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -28,7 +28,7 @@ module RuboCop
       #     x.attr = 5
       #     x
       #   end
-      class UselessSetterCall < Cop
+      class UselessSetterCall < Base
         MSG = 'Useless setter call to local variable `%<variable>s`.'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
@@ -43,11 +43,9 @@ module RuboCop
           variable_name, = *receiver
           return unless tracker.contain_local_object?(variable_name)
 
-          add_offense(
-            receiver,
-            location: :name,
-            message: format(MSG, variable: receiver.loc.name.source)
-          )
+          loc_name = receiver.loc.name
+
+          add_offense(loc_name, message: format(MSG, variable: loc_name.source))
         end
         alias on_defs on_def
 

data/lib/rubocop/cop/lint/void.rb

@@ -40,7 +40,7 @@ module RuboCop
       #     some_array.sort!
       #     do_something(some_array)
       #   end
-      class Void < Cop
+      class Void < Base
         OP_MSG = 'Operator `%<op>s` used in void context.'
         VAR_MSG = 'Variable `%<var>s` used in void context.'
         LIT_MSG = 'Literal `%<lit>s` used in void context.'
@@ -97,17 +97,13 @@ module RuboCop
         def check_void_op(node)
           return unless node.send_type? && OPERATORS.include?(node.method_name)
 
-          add_offense(node,
-                      location: :selector,
-                      message: format(OP_MSG, op: node.method_name))
+          add_offense(node.loc.selector, message: format(OP_MSG, op: node.method_name))
         end
 
         def check_var(node)
           return unless node.variable? || node.const_type?
 
-          add_offense(node,
-                      location: :name,
-                      message: format(VAR_MSG, var: node.loc.name.source))
+          add_offense(node.loc.name, message: format(VAR_MSG, var: node.loc.name.source))
         end
 
         def check_literal(node)

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

@@ -7,7 +7,7 @@ module RuboCop
       # 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
+      class AbcSize < Base
         include MethodComplexity
 
         MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \

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

@@ -29,8 +29,8 @@ module RuboCop
       #       content.
       #     HEREDOC
       #   end                 # 5 points
-      class BlockLength < Cop
-        include TooManyLines
+      class BlockLength < Base
+        include CodeLength
 
         LABEL = 'Block'
 

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

@@ -11,7 +11,7 @@ module RuboCop
       # towards the nesting level. Set to `true` to count blocks as well.
       #
       # The maximum level of nesting allowed is configurable.
-      class BlockNesting < Cop
+      class BlockNesting < Base
         include ConfigurableMax
 
         NESTING_BLOCKS = %i[
@@ -19,7 +19,7 @@ module RuboCop
           until until_post for resbody
         ].freeze
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
           max = cop_config['Max']

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

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

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

@@ -29,7 +29,7 @@ module RuboCop
       #
       #     self
       #   end                                       # total: 6
-      class CyclomaticComplexity < Cop
+      class CyclomaticComplexity < Base
         include MethodComplexity
         include Utils::IteratingBlock
 
@@ -42,6 +42,7 @@ module RuboCop
 
         def complexity_score_for(node)
           return 0 if iterating_block?(node) == false
+          return 0 if node.csend_type? && discount_for_repeated_csend?(node)
 
           1
         end

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,39 @@ 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
+
           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 +61,7 @@ module RuboCop
               @condition += 1
             else
               @branch += 1
+              @condition += 1 if node.csend_type? && !discount_for_repeated_csend?(node)
             end
           end
 
@@ -70,11 +78,46 @@ module RuboCop
 
           private
 
+          def assignment?(node)
+            node.for_type? ||
+              node.op_asgn_type? ||
+              (node.respond_to?(:setter_method?) && node.setter_method?) ||
+              (simple_assignment?(node) && capturing_variable?(node.children.first))
+          end
+
+          def simple_assignment?(node)
+            return false if node.masgn_type?
+
+            if node.equals_asgn?
+              reset_on_lvasgn(node) if node.lvasgn_type?
+              return true
+            end
+
+            argument?(node)
+          end
+
+          def capturing_variable?(name)
+            name && !/^_/.match?(name)
+          end
+
+          # Returns true for nodes which otherwise would be counted
+          # as one too many assignment
+          def assignment_doubled_in_ast?(node)
+            node.masgn_type? || node.or_asgn_type? || node.and_asgn_type?
+          end
+
           def branch?(node)
             BRANCH_NODES.include?(node.type)
           end
 
+          # TODO: move to rubocop-ast
+          def argument?(node)
+            ARGUMENT_TYPES.include?(node.type)
+          end
+
           def condition?(node)
+            return false if iterating_block?(node) == false
+
             CONDITION_NODES.include?(node.type)
           end
         end