rubocop 0.76.0 → 0.83.0

data/lib/rubocop/cop/style/method_call_with_args_parentheses.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Style
@@ -43,7 +42,6 @@ module RuboCop
       #
       # @example EnforcedStyle: require_parentheses (default)
       #
-      #
       #   # bad
       #   array.delete e
       #
@@ -150,94 +148,23 @@ module RuboCop
         include IgnoredMethods
         include IgnoredPattern
 
-        TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
+        def initialize(*)
+          super
+          return unless style_configured?
 
-        def on_send(node)
           case style
           when :require_parentheses
-            add_offense_for_require_parentheses(node)
+            extend RequireParentheses
           when :omit_parentheses
-            add_offense_for_omit_parentheses(node)
+            extend OmitParentheses
           end
         end
-        alias on_csend on_send
-        alias on_super on_send
-        alias on_yield on_send
 
-        def autocorrect(node)
-          case style
-          when :require_parentheses
-            autocorrect_for_require_parentheses(node)
-          when :omit_parentheses
-            autocorrect_for_omit_parentheses(node)
-          end
-        end
-
-        def message(_node = nil)
-          case style
-          when :require_parentheses
-            'Use parentheses for method calls with arguments.'
-          when :omit_parentheses
-            'Omit parentheses for method calls with arguments.'
-          end
-        end
+        # @abstract Overridden in style modules
+        def autocorrect(_node); end
 
         private
 
-        def add_offense_for_require_parentheses(node)
-          return if ignored_method?(node.method_name)
-          return if matches_ignored_pattern?(node.method_name)
-          return if eligible_for_parentheses_omission?(node)
-          return unless node.arguments? && !node.parenthesized?
-
-          add_offense(node)
-        end
-
-        def add_offense_for_omit_parentheses(node)
-          return unless node.parenthesized?
-          return if node.implicit_call?
-          return if super_call_without_arguments?(node)
-          return if allowed_camel_case_method_call?(node)
-          return if legitimate_call_with_parentheses?(node)
-
-          add_offense(node, location: node.loc.begin.join(node.loc.end))
-        end
-
-        def autocorrect_for_require_parentheses(node)
-          lambda do |corrector|
-            corrector.replace(args_begin(node), '(')
-
-            unless args_parenthesized?(node)
-              corrector.insert_after(args_end(node), ')')
-            end
-          end
-        end
-
-        def autocorrect_for_omit_parentheses(node)
-          lambda do |corrector|
-            if parentheses_at_the_end_of_multiline_call?(node)
-              corrector.replace(args_begin(node), ' \\')
-            else
-              corrector.replace(args_begin(node), ' ')
-            end
-            corrector.remove(node.loc.end)
-          end
-        end
-
-        def eligible_for_parentheses_omission?(node)
-          node.operator_method? || node.setter_method? || ignored_macro?(node)
-        end
-
-        def included_macros_list
-          cop_config.fetch('IncludedMacros', []).map(&:to_sym)
-        end
-
-        def ignored_macro?(node)
-          cop_config['IgnoreMacros'] &&
-            node.macro? &&
-            !included_macros_list.include?(node.method_name)
-        end
-
         def args_begin(node)
           loc = node.loc
           selector =
@@ -257,132 +184,7 @@ module RuboCop
           first_node = node.arguments.first
           first_node.begin_type? && first_node.parenthesized_call?
         end
-
-        def parentheses_at_the_end_of_multiline_call?(node)
-          node.multiline? &&
-            node.loc.begin.source_line
-                .gsub(TRAILING_WHITESPACE_REGEX, '')
-                .end_with?('(')
-        end
-
-        def super_call_without_arguments?(node)
-          node.super_type? && node.arguments.none?
-        end
-
-        def allowed_camel_case_method_call?(node)
-          node.camel_case_method? &&
-            (node.arguments.none? ||
-             cop_config['AllowParenthesesInCamelCaseMethod'])
-        end
-
-        def legitimate_call_with_parentheses?(node)
-          call_in_literals?(node) ||
-            call_with_ambiguous_arguments?(node) ||
-            call_in_logical_operators?(node) ||
-            call_in_optional_arguments?(node) ||
-            allowed_multiline_call_with_parentheses?(node) ||
-            allowed_chained_call_with_parentheses?(node)
-        end
-
-        def call_in_literals?(node)
-          node.parent &&
-            (node.parent.pair_type? ||
-             node.parent.array_type? ||
-             node.parent.range_type? ||
-             splat?(node.parent) ||
-             ternary_if?(node.parent))
-        end
-
-        def call_in_logical_operators?(node)
-          node.parent &&
-            (logical_operator?(node.parent) ||
-             node.parent.send_type? &&
-             node.parent.arguments.any?(&method(:logical_operator?)))
-        end
-
-        def call_in_optional_arguments?(node)
-          node.parent &&
-            (node.parent.optarg_type? || node.parent.kwoptarg_type?)
-        end
-
-        def call_with_ambiguous_arguments?(node)
-          call_with_braced_block?(node) ||
-            call_as_argument_or_chain?(node) ||
-            hash_literal_in_arguments?(node) ||
-            node.descendants.any? do |n|
-              ambigious_literal?(n) || logical_operator?(n) ||
-                call_with_braced_block?(n)
-            end
-        end
-
-        def call_with_braced_block?(node)
-          (node.send_type? || node.super_type?) &&
-            node.block_node && node.block_node.braces?
-        end
-
-        def call_as_argument_or_chain?(node)
-          node.parent &&
-            (node.parent.send_type? && !assigned_before?(node.parent, node) ||
-             node.parent.csend_type? || node.parent.super_type?)
-        end
-
-        def hash_literal_in_arguments?(node)
-          node.arguments.any? do |n|
-            hash_literal?(n) ||
-              n.send_type? && node.descendants.any?(&method(:hash_literal?))
-          end
-        end
-
-        def allowed_multiline_call_with_parentheses?(node)
-          cop_config['AllowParenthesesInMultilineCall'] && node.multiline?
-        end
-
-        def allowed_chained_call_with_parentheses?(node)
-          return false unless cop_config['AllowParenthesesInChaining']
-
-          previous = node.descendants.first
-          return false unless previous&.send_type?
-
-          previous.parenthesized? ||
-            allowed_chained_call_with_parentheses?(previous)
-        end
-
-        def ambigious_literal?(node)
-          splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) ||
-            unary_literal?(node)
-        end
-
-        def splat?(node)
-          node.splat_type? || node.kwsplat_type? || node.block_pass_type?
-        end
-
-        def ternary_if?(node)
-          node.if_type? && node.ternary?
-        end
-
-        def logical_operator?(node)
-          (node.and_type? || node.or_type?) && node.logical_operator?
-        end
-
-        def hash_literal?(node)
-          node.hash_type? && node.braces?
-        end
-
-        def regexp_slash_literal?(node)
-          node.regexp_type? && node.loc.begin.source == '/'
-        end
-
-        def unary_literal?(node)
-          node.numeric_type? && node.sign? ||
-            node.parent&.send_type? && node.parent&.unary_operation?
-        end
-
-        def assigned_before?(node, target)
-          node.assignment? &&
-            node.loc.operator.begin < target.loc.begin
-        end
       end
     end
   end
 end
-# rubocop:enable Metrics/ClassLength

data/lib/rubocop/cop/style/mixin_grouping.rb

@@ -72,7 +72,7 @@ module RuboCop
           between = prev_mixin.loc.expression.end
                               .join(range.begin)
           # if separated from previous mixin with only whitespace?
-          if between.source !~ /\S/
+          unless /\S/.match?(between.source)
             range = range.join(between) # then remove that too
           end
           range
@@ -103,7 +103,7 @@ module RuboCop
                               .select(&:macro?)
 
           siblings.select do |sibling_node|
-            sibling_node.method_name == send_node.method_name
+            sibling_node.method?(send_node.method_name)
           end
         end
 

data/lib/rubocop/cop/style/module_function.rb

@@ -6,7 +6,7 @@ module RuboCop
       # This cop checks for use of `extend self` or `module_function` in a
       # module.
       #
-      # Supported styles are: module_function, extend_self.
+      # Supported styles are: module_function, extend_self, forbidden.
       #
       # @example EnforcedStyle: module_function (default)
       #   # bad
@@ -46,6 +46,29 @@ module RuboCop
       #     # ...
       #   end
       #
+      # The option `forbidden` prohibits the usage of both styles.
+      #
+      # @example EnforcedStyle: forbidden
+      #   # bad
+      #   module Test
+      #     module_function
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #     private
+      #     # ...
+      #   end
+      #
       # These offenses are not safe to auto-correct since there are different
       # implications to each approach.
       class ModuleFunction < Cop
@@ -55,6 +78,8 @@ module RuboCop
           'Use `module_function` instead of `extend self`.'
         EXTEND_SELF_MSG =
           'Use `extend self` instead of `module_function`.'
+        FORBIDDEN_MSG =
+          'Do not use `module_function` or `extend self`.'
 
         def_node_matcher :module_function_node?, '(send nil? :module_function)'
         def_node_matcher :extend_self_node?, '(send nil? :extend self)'
@@ -69,33 +94,54 @@ module RuboCop
         end
 
         def autocorrect(node)
+          return if style == :forbidden
+
           lambda do |corrector|
             if extend_self_node?(node)
-              corrector.replace(node.source_range, 'module_function')
+              corrector.replace(node, 'module_function')
             else
-              corrector.replace(node.source_range, 'extend self')
+              corrector.replace(node, 'extend self')
             end
           end
         end
 
         private
 
-        def each_wrong_style(nodes)
+        def each_wrong_style(nodes, &block)
           case style
           when :module_function
-            private_directive = nodes.any? { |node| private_directive?(node) }
-
-            nodes.each do |node|
-              yield node if extend_self_node?(node) && !private_directive
-            end
+            check_module_function(nodes, &block)
           when :extend_self
-            nodes.each do |node|
-              yield node if module_function_node?(node)
-            end
+            check_extend_self(nodes, &block)
+          when :forbidden
+            check_forbidden(nodes, &block)
+          end
+        end
+
+        def check_module_function(nodes)
+          private_directive = nodes.any? { |node| private_directive?(node) }
+
+          nodes.each do |node|
+            yield node if extend_self_node?(node) && !private_directive
+          end
+        end
+
+        def check_extend_self(nodes)
+          nodes.each do |node|
+            yield node if module_function_node?(node)
+          end
+        end
+
+        def check_forbidden(nodes)
+          nodes.each do |node|
+            yield node if extend_self_node?(node)
+            yield node if module_function_node?(node)
           end
         end
 
         def message(_node)
+          return FORBIDDEN_MSG if style == :forbidden
+
           style == :module_function ? MODULE_FUNCTION_MSG : EXTEND_SELF_MSG
         end
       end

data/lib/rubocop/cop/style/multiline_if_modifier.rb

@@ -29,7 +29,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, to_normal_if(node))
+            corrector.replace(node, to_normal_if(node))
           end
         end
 

data/lib/rubocop/cop/style/multiline_memoization.rb

@@ -82,7 +82,7 @@ module RuboCop
         end
 
         def keyword_end_str(node, node_buf)
-          if node_buf.source_line(node.loc.end.line) =~ /[^\s\)]/
+          if /[^\s\)]/.match?(node_buf.source_line(node.loc.end.line))
             "\n" + (' ' * node.loc.column) + 'end'
           else
             'end'

data/lib/rubocop/cop/style/multiline_method_signature.rb

@@ -53,7 +53,7 @@ module RuboCop
         end
 
         def max_line_length
-          config.for_cop('Metrics/LineLength')['Max'] || 80
+          config.for_cop('Layout/LineLength')['Max'] || 80
         end
       end
     end

data/lib/rubocop/cop/style/multiline_when_then.rb

@@ -22,6 +22,12 @@ module RuboCop
       #   when bar then do_something
       #   end
       #
+      #   # good
+      #   case foo
+      #   when bar then do_something(arg1,
+      #                              arg2)
+      #   end
+      #
       class MultilineWhenThen < Cop
         include RangeHelp
 
@@ -32,10 +38,13 @@ module RuboCop
           return unless node.then?
 
           # Single line usage of `then` is not an offense
-          return if !node.children.last.nil? && !node.multiline? && node.then?
+          return if !node.children.last.nil? && !node.multiline?
+
+          # Requires `then` for write `when` and its body on the same line.
+          return if require_then?(node)
 
           # With more than one statements after then, there's not offense
-          return if node.children.last&.begin_type?
+          return if accept_node_type?(node.body)
 
           add_offense(node, location: :begin)
         end
@@ -49,6 +58,16 @@ module RuboCop
             )
           end
         end
+
+        def require_then?(when_node)
+          return false unless when_node.body
+
+          when_node.loc.line == when_node.body.loc.line
+        end
+
+        def accept_node_type?(node)
+          node&.begin_type? || node&.array_type? || node&.hash_type?
+        end
       end
     end
   end

data/lib/rubocop/cop/style/mutable_constant.rb

@@ -77,11 +77,9 @@ module RuboCop
             if splat_value
               correct_splat_expansion(corrector, expr, splat_value)
             elsif node.array_type? && !node.bracketed?
-              corrector.insert_before(expr, '[')
-              corrector.insert_after(expr, ']')
+              corrector.wrap(expr, '[', ']')
             elsif requires_parentheses?(node)
-              corrector.insert_before(expr, '(')
-              corrector.insert_after(expr, ')')
+              corrector.wrap(expr, '(', ')')
             end
 
             corrector.insert_after(expr, '.freeze')

data/lib/rubocop/cop/style/nested_parenthesized_calls.rb

@@ -8,10 +8,10 @@ module RuboCop
       #
       # @example
       #   # good
-      #   method1(method2(arg), method3(arg))
+      #   method1(method2(arg))
       #
       #   # bad
-      #   method1(method2 arg, method3, arg)
+      #   method1(method2 arg)
       class NestedParenthesizedCalls < Cop
         include RangeHelp
 
@@ -35,8 +35,8 @@ module RuboCop
           last_arg = nested.last_argument.source_range
 
           leading_space =
-            range_with_surrounding_space(range: first_arg,
-                                         side: :left).begin.resize(1)
+            range_with_surrounding_space(range: first_arg.begin,
+                                         side: :left)
 
           lambda do |corrector|
             corrector.replace(leading_space, '(')
@@ -49,17 +49,17 @@ module RuboCop
         def allowed_omission?(send_node)
           !send_node.arguments? || send_node.parenthesized? ||
             send_node.setter_method? || send_node.operator_method? ||
-            whitelisted?(send_node)
+            allowed?(send_node)
         end
 
-        def whitelisted?(send_node)
+        def allowed?(send_node)
           send_node.parent.arguments.one? &&
-            whitelisted_methods.include?(send_node.method_name.to_s) &&
+            allowed_methods.include?(send_node.method_name.to_s) &&
             send_node.arguments.one?
         end
 
-        def whitelisted_methods
-          cop_config['Whitelist'] || []
+        def allowed_methods
+          cop_config['AllowedMethods'] || []
         end
       end
     end

data/lib/rubocop/cop/style/next.rb

@@ -20,18 +20,18 @@ module RuboCop
       #   end
       #
       #   # good
-      #   [1, 2].each do |o|
-      #     puts o unless o == 1
+      #   [1, 2].each do |a|
+      #     puts a if a == 1
       #   end
       #
       # @example EnforcedStyle: always
       #   # With `always` all conditions at the end of an iteration needs to be
       #   # replaced by next - with `skip_modifier_ifs` the modifier if like
-      #   # this one are ignored: `[1, 2].each { |a| return 'yes' if a == 1 }`
+      #   # this one are ignored: `[1, 2].each { |a| puts a if a == 1 }`
       #
       #   # bad
-      #   [1, 2].each do |o|
-      #     puts o unless o == 1
+      #   [1, 2].each do |a|
+      #     puts a if a == 1
       #   end
       #
       #   # bad
@@ -152,13 +152,13 @@ module RuboCop
             "next #{node.inverse_keyword} #{node.condition.source}\n" \
             "#{' ' * node.source_range.column}#{body.source}"
 
-          corrector.replace(node.source_range, replacement)
+          corrector.replace(node, replacement)
         end
 
         def autocorrect_block(corrector, node)
           next_code = "next #{node.inverse_keyword} #{node.condition.source}"
 
-          corrector.insert_before(node.source_range, next_code)
+          corrector.insert_before(node, next_code)
 
           corrector.remove(cond_range(node, node.condition))
           corrector.remove(end_range(node))

data/lib/rubocop/cop/style/nil_comparison.rb

@@ -49,7 +49,7 @@ module RuboCop
                      else
                        node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
                      end
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
+          ->(corrector) { corrector.replace(node, new_code) }
         end
 
         private

data/lib/rubocop/cop/style/non_nil_check.rb

@@ -111,15 +111,15 @@ module RuboCop
 
           return if expr == new_code
 
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
+          ->(corrector) { corrector.replace(node, new_code) }
         end
 
         def autocorrect_non_nil(node, inner_node)
           lambda do |corrector|
             if inner_node.receiver
-              corrector.replace(node.source_range, inner_node.receiver.source)
+              corrector.replace(node, inner_node.receiver.source)
             else
-              corrector.replace(node.source_range, 'self')
+              corrector.replace(node, 'self')
             end
           end
         end
@@ -127,7 +127,7 @@ module RuboCop
         def autocorrect_unless_nil(node, receiver)
           lambda do |corrector|
             corrector.replace(node.parent.loc.keyword, 'if')
-            corrector.replace(node.source_range, receiver.source)
+            corrector.replace(node, receiver.source)
           end
         end
       end

data/lib/rubocop/cop/style/not.rb

@@ -69,7 +69,7 @@ module RuboCop
         def correct_with_parens(range, node)
           lambda do |corrector|
             corrector.replace(range, '!(')
-            corrector.insert_after(node.source_range, ')')
+            corrector.insert_after(node, ')')
           end
         end
 

data/lib/rubocop/cop/style/numeric_literal_prefix.rb

@@ -59,7 +59,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             type = literal_type(node)
-            corrector.replace(node.source_range,
+            corrector.replace(node,
                               send(:"format_#{type}", node.source))
           end
         end

data/lib/rubocop/cop/style/numeric_literals.rb

@@ -9,18 +9,22 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   1000000
       #   1_00_000
       #   1_0000
       #
       #   # good
-      #
       #   1_000_000
       #   1000
       #
-      #   # good unless Strict is set
+      # @example Strict: false (default)
       #
+      #   # good
+      #   10_000_00 # typical representation of $10,000 in cents
+      #
+      # @example Strict: true
+      #
+      #   # bad
       #   10_000_00 # typical representation of $10,000 in cents
       #
       class NumericLiterals < Cop
@@ -44,7 +48,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, format_number(node))
+            corrector.replace(node, format_number(node))
           end
         end
 

data/lib/rubocop/cop/style/numeric_predicate.rb

@@ -54,9 +54,10 @@ module RuboCop
         }.freeze
 
         def on_send(node)
-          return if node.each_ancestor(:send, :block).any? do |ancestor|
-            ignored_method?(ancestor.method_name)
-          end
+          return if ignored_method?(node.method_name) ||
+                    node.each_ancestor(:send, :block).any? do |ancestor|
+                      ignored_method?(ancestor.method_name)
+                    end
 
           numeric, replacement = check(node)
 
@@ -72,7 +73,7 @@ module RuboCop
           _, replacement = check(node)
 
           lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement)
+            corrector.replace(node, replacement)
           end
         end