rubocop 0.78.0 → 1.13.0

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

@@ -46,13 +46,12 @@ module RuboCop
       #   f = ->(x) do
       #         x
       #       end
-      class Lambda < Cop
+      class Lambda < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for ' \
-                          '%<modifier>s lambdas.'
-        METHOD_MESSAGE = 'Use the `lambda` method for %<modifier>s ' \
-                         'lambdas.'
+        LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for %<modifier>s lambdas.'
+        METHOD_MESSAGE = 'Use the `lambda` method for %<modifier>s lambdas.'
 
         OFFENDING_SELECTORS = {
           style: {
@@ -69,20 +68,15 @@ module RuboCop
 
           return unless offending_selector?(node, selector)
 
-          add_offense(node,
-                      location: node.send_node.source_range,
-                      message: message(node, selector))
-        end
-
-        def autocorrect(node)
-          if node.send_node.source == 'lambda'
-            lambda do |corrector|
+          add_offense(node.send_node.source_range, message: message(node, selector)) do |corrector|
+            if node.send_node.source == 'lambda'
               autocorrect_method_to_literal(corrector, node)
+            else
+              LambdaLiteralToMethodCorrector.new(node).call(corrector)
             end
-          else
-            LambdaLiteralToMethodCorrector.new(node)
           end
         end
+        alias on_numblock on_block
 
         private
 
@@ -108,13 +102,13 @@ module RuboCop
         end
 
         def autocorrect_method_to_literal(corrector, node)
-          corrector.replace(node.send_node.source_range, '->')
+          corrector.replace(node.send_node, '->')
 
           return unless node.arguments?
 
           arg_str = "(#{lambda_arg_string(node.arguments)})"
 
-          corrector.insert_after(node.send_node.source_range, arg_str)
+          corrector.insert_after(node.send_node, arg_str)
           corrector.remove(arguments_with_whitespace(node))
         end
 

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

@@ -18,58 +18,41 @@ module RuboCop
       #
       #  # good
       #  lambda.(x, y)
-      class LambdaCall < Cop
+      class LambdaCall < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[call].freeze
 
         def on_send(node)
-          return unless node.receiver && node.method?(:call)
+          return unless node.receiver
 
           if offense?(node)
-            add_offense(node) { opposite_style_detected }
+            add_offense(node) do |corrector|
+              opposite_style_detected
+              autocorrect(corrector, node)
+            end
           else
             correct_style_detected
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if explicit_style?
-              receiver = node.receiver.source
-              replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
+        def autocorrect(corrector, node)
+          if explicit_style?
+            receiver = node.receiver.source
+            replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
 
-              corrector.replace(node.source_range, replacement)
-            else
-              add_parentheses(node, corrector) unless node.parenthesized?
-              corrector.remove(node.loc.selector)
-            end
+            corrector.replace(node, replacement)
+          else
+            add_parentheses(node, corrector) unless node.parenthesized?
+            corrector.remove(node.loc.selector)
           end
         end
 
         private
 
         def offense?(node)
-          explicit_style? && node.implicit_call? ||
-            implicit_style? && !node.implicit_call?
-        end
-
-        def add_parentheses(node, corrector)
-          if node.arguments.empty?
-            corrector.insert_after(node.source_range, '()')
-          else
-            corrector.replace(args_begin(node), '(')
-            corrector.insert_after(args_end(node), ')')
-          end
-        end
-
-        def args_begin(node)
-          loc = node.loc
-          selector =
-            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
-          selector.end.resize(1)
-        end
-
-        def args_end(node)
-          node.loc.expression.end
+          explicit_style? && node.implicit_call? || implicit_style? && !node.implicit_call?
         end
 
         def message(_node)

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

@@ -19,40 +19,24 @@ module RuboCop
       #   some_str = 'ala' \
       #              'bala'
       #
-      class LineEndConcatenation < Cop
+      class LineEndConcatenation < Base
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Use `\\` instead of `+` or `<<` to concatenate ' \
-              'those strings.'
+        MSG = 'Use `\\` instead of `+` or `<<` to concatenate those strings.'
         CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
         COMPLEX_STRING_BEGIN_TOKEN = :tSTRING_BEG
         COMPLEX_STRING_END_TOKEN = :tSTRING_END
-        HIGH_PRECEDENCE_OP_TOKEN_TYPES = %i[tSTAR2 tPERCENT tDOT
-                                            tLBRACK2].freeze
+        HIGH_PRECEDENCE_OP_TOKEN_TYPES = %i[tSTAR2 tPERCENT tDOT tLBRACK2].freeze
         QUOTE_DELIMITERS = %w[' "].freeze
 
         def self.autocorrect_incompatible_with
           [Style::RedundantInterpolation]
         end
 
-        def investigate(processed_source)
-          processed_source.tokens.each_index do |index|
-            check_token_set(index)
-          end
-        end
-
-        def autocorrect(operator_range)
-          # Include any trailing whitespace so we don't create a syntax error.
-          operator_range = range_with_surrounding_space(range: operator_range,
-                                                        side: :right,
-                                                        newlines: false)
-          one_more_char = operator_range.resize(operator_range.size + 1)
-          # Don't create a double backslash at the end of the line, in case
-          # there already was a backslash after the concatenation operator.
-          operator_range = one_more_char if one_more_char.source.end_with?('\\')
-
-          ->(corrector) { corrector.replace(operator_range, '\\') }
+        def on_new_investigation
+          processed_source.tokens.each_index { |index| check_token_set(index) }
         end
 
         private
@@ -68,7 +52,20 @@ module RuboCop
 
           return unless eligible_next_successor?(next_successor)
 
-          add_offense(operator.pos, location: operator.pos)
+          add_offense(operator.pos) { |corrector| autocorrect(corrector, operator.pos) }
+        end
+
+        def autocorrect(corrector, operator_range)
+          # Include any trailing whitespace so we don't create a syntax error.
+          operator_range = range_with_surrounding_space(range: operator_range,
+                                                        side: :right,
+                                                        newlines: false)
+          one_more_char = operator_range.resize(operator_range.size + 1)
+          # Don't create a double backslash at the end of the line, in case
+          # there already was a backslash after the concatenation operator.
+          operator_range = one_more_char if one_more_char.source.end_with?('\\')
+
+          corrector.replace(operator_range, '\\')
         end
 
         def eligible_token_set?(predecessor, operator, successor)
@@ -86,8 +83,7 @@ module RuboCop
         end
 
         def eligible_next_successor?(next_successor)
-          !(next_successor &&
-            HIGH_PRECEDENCE_OP_TOKEN_TYPES.include?(next_successor.type))
+          !(next_successor && HIGH_PRECEDENCE_OP_TOKEN_TYPES.include?(next_successor.type))
         end
 
         def eligible_predecessor?(predecessor)

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
@@ -41,8 +40,14 @@ module RuboCop
       #     to `true` allows the presence of parentheses in such a method call
       #     even with arguments.
       #
-      # @example EnforcedStyle: require_parentheses (default)
+      # NOTE: Parentheses are still allowed in cases where omitting them
+      # results in ambiguous or syntactically incorrect code. For example,
+      # parentheses are required around a method with arguments when inside an
+      # endless method definition introduced in Ruby 3.0.  Parentheses are also
+      # allowed when forwarding arguments with the triple-dot syntax introduced
+      # in Ruby 2.7 as omitting them starts an endless range.
       #
+      # @example EnforcedStyle: require_parentheses (default)
       #
       #   # bad
       #   array.delete e
@@ -78,6 +83,30 @@ module RuboCop
       #   # good
       #   foo.enforce strict: true
       #
+      #   # good
+      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   model.validate strict(true)
+      #
+      #   # good
+      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   yield path, File.basename(path)
+      #
+      #   # good
+      #   # Operators methods calls with parens
+      #   array&.[](index)
+      #
+      #   # good
+      #   # Operators methods without parens, if you prefer
+      #   array.[] index
+      #
+      #   # good
+      #   # Operators methods calls with parens
+      #   array&.[](index)
+      #
+      #   # good
+      #   # Operators methods without parens, if you prefer
+      #   array.[] index
+      #
       # @example IgnoreMacros: true (default)
       #
       #   # good
@@ -145,99 +174,46 @@ module RuboCop
       #
       #   # good
       #   Array 1
-      class MethodCallWithArgsParentheses < Cop
+      #
+      # @example AllowParenthesesInStringInterpolation: false (default)
+      #
+      #   # bad
+      #   "#{t('this.is.bad')}"
+      #
+      #   # good
+      #   "#{t 'this.is.better'}"
+      #
+      # @example AllowParenthesesInStringInterpolation: true
+      #
+      #   # good
+      #   "#{t('this.is.good')}"
+      #
+      #   # good
+      #   "#{t 'this.is.also.good'}"
+      class MethodCallWithArgsParentheses < Base
+        require_relative 'method_call_with_args_parentheses/omit_parentheses'
+        require_relative 'method_call_with_args_parentheses/require_parentheses'
+
         include ConfigurableEnforcedStyle
         include IgnoredMethods
         include IgnoredPattern
+        include RequireParentheses
+        include OmitParentheses
+        extend AutoCorrector
 
-        TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
+        def self.autocorrect_incompatible_with
+          [Style::NestedParenthesizedCalls, Style::RescueModifier]
+        end
 
         def on_send(node)
-          case style
-          when :require_parentheses
-            add_offense_for_require_parentheses(node)
-          when :omit_parentheses
-            add_offense_for_omit_parentheses(node)
-          end
+          send(style, node) # call require_parentheses or omit_parentheses
         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
-
         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 +233,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