rubocop 0.52.1 → 0.93.1

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

@@ -46,13 +46,14 @@ 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.'.freeze
+                          '%<modifier>s lambdas.'
         METHOD_MESSAGE = 'Use the `lambda` method for %<modifier>s ' \
-                         'lambdas.'.freeze
+                         'lambdas.'
 
         OFFENDING_SELECTORS = {
           style: {
@@ -62,8 +63,6 @@ module RuboCop
           }
         }.freeze
 
-        def_node_matcher :lambda_node?, '(block $(send nil? :lambda) ...)'
-
         def on_block(node)
           return unless node.lambda?
 
@@ -71,26 +70,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)
-          block_method, _args = *node
-          selector = block_method.source
-
-          # Don't autocorrect if this would change the meaning of the code
-          return if selector == '->' && arg_to_unparenthesized_call?(node)
-
-          lambda do |corrector|
-            if selector == 'lambda'
+          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
-              autocorrect_literal_to_method(corrector, node)
+              LambdaLiteralToMethodCorrector.new(node).call(corrector)
             end
           end
         end
+        alias on_numblock on_block
 
         private
 
@@ -115,96 +103,24 @@ module RuboCop
           end
         end
 
-        def autocorrect_literal_to_method(corrector, node)
-          block_method, args = *node
-
-          # Check for unparenthesized args' preceding and trailing whitespaces.
-          remove_unparenthesized_whitespace(corrector, node)
-
-          # Avoid correcting to `lambdado` by inserting whitespace
-          # if none exists before or after the lambda arguments.
-          if needs_whitespace?(block_method, args, node)
-            corrector.insert_before(node.loc.begin, ' ')
-          end
-          corrector.replace(block_method.source_range, 'lambda')
-          corrector.remove(args.source_range) if args.source_range
-          return if args.children.empty?
-          arg_str = " |#{lambda_arg_string(args)}|"
-          corrector.insert_after(node.loc.begin, arg_str)
-        end
-
         def autocorrect_method_to_literal(corrector, node)
-          block_method, args = *node
-          corrector.replace(block_method.source_range, '->')
-          return if args.children.empty?
-
-          arg_str = "(#{lambda_arg_string(args)})"
-          whitespace_and_old_args = node.loc.begin.end.join(args.loc.end)
-          corrector.insert_after(block_method.source_range, arg_str)
-          corrector.remove(whitespace_and_old_args)
-        end
+          corrector.replace(node.send_node, '->')
 
-        def needs_whitespace?(block_method, args, node)
-          selector_end = block_method.loc.selector.end.end_pos
-          block_begin  = node.loc.begin.begin_pos
+          return unless node.arguments?
 
-          (block_begin == end_pos(args) && selector_end == begin_pos(args)) ||
-            (block_begin == selector_end)
-        end
+          arg_str = "(#{lambda_arg_string(node.arguments)})"
 
-        def begin_pos(node)
-          node.loc.begin && node.loc.begin.begin_pos
+          corrector.insert_after(node.send_node, arg_str)
+          corrector.remove(arguments_with_whitespace(node))
         end
 
-        def end_pos(node)
-          node.loc.end && node.loc.end.end_pos
+        def arguments_with_whitespace(node)
+          node.loc.begin.end.join(node.arguments.loc.end)
         end
 
         def lambda_arg_string(args)
           args.children.map(&:source).join(', ')
         end
-
-        def arg_to_unparenthesized_call?(arg_node)
-          parent = arg_node.parent
-
-          if parent && parent.pair_type?
-            arg_node = parent.parent
-            parent = arg_node.parent
-          end
-
-          return false unless parent && parent.send_type?
-          return false if parenthesized_call?(parent)
-
-          arg_node.sibling_index > 1
-        end
-
-        def remove_unparenthesized_whitespace(corrector, node)
-          args = node.arguments
-
-          return unless unparenthesized_literal_args?(args)
-
-          remove_leading_whitespace(node, corrector)
-          remove_trailing_whitespace(node, corrector)
-        end
-
-        def remove_leading_whitespace(node, corrector)
-          corrector.remove_preceding(
-            node.arguments.source_range,
-            node.arguments.source_range.begin_pos -
-              node.send_node.source_range.end_pos
-          )
-        end
-
-        def remove_trailing_whitespace(node, corrector)
-          corrector.remove_preceding(
-            node.loc.begin,
-            node.loc.begin.begin_pos - node.arguments.source_range.end_pos - 1
-          )
-        end
-
-        def unparenthesized_literal_args?(args)
-          args.source_range && args.source_range.begin && !parentheses?(args)
-        end
       end
     end
   end

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

@@ -18,30 +18,33 @@ 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 }
+          if offense?(node) && opposite_style_detected
+            add_offense(node) do |corrector|
+              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
 
@@ -52,26 +55,6 @@ module RuboCop
             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
-        end
-
         def message(_node)
           if explicit_style?
             'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'

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

@@ -19,47 +19,36 @@ 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.'.freeze
+              'those strings.'
         CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
-        COMPLEX_STRING_EDGE_TOKEN_TYPES = %i[tSTRING_BEG tSTRING_END].freeze
+        COMPLEX_STRING_BEGIN_TOKEN = :tSTRING_BEG
+        COMPLEX_STRING_END_TOKEN = :tSTRING_END
         HIGH_PRECEDENCE_OP_TOKEN_TYPES = %i[tSTAR2 tPERCENT tDOT
                                             tLBRACK2].freeze
         QUOTE_DELIMITERS = %w[' "].freeze
 
         def self.autocorrect_incompatible_with
-          [Style::UnneededInterpolation]
+          [Style::RedundantInterpolation]
         end
 
-        def investigate(processed_source)
+        def on_new_investigation
           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, '\\') }
-        end
-
         private
 
         def check_token_set(index)
           predecessor, operator, successor = processed_source.tokens[index, 3]
 
-          return unless eligible_successor?(successor) &&
-                        eligible_operator?(operator) &&
-                        eligible_predecessor?(predecessor)
+          return unless eligible_token_set?(predecessor, operator, successor)
 
           return if operator.line == successor.line
 
@@ -67,7 +56,28 @@ module RuboCop
 
           return unless eligible_next_successor?(next_successor)
 
-          add_offense(operator.pos, location: operator.pos)
+          add_offense(operator.pos) do |corrector|
+            autocorrect(corrector, operator.pos)
+          end
+        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)
+          eligible_successor?(successor) &&
+            eligible_operator?(operator) &&
+            eligible_predecessor?(predecessor)
         end
 
         def eligible_successor?(successor)
@@ -89,13 +99,12 @@ module RuboCop
 
         def token_after_last_string(successor, base_index)
           index = base_index + 3
-          begin_token, end_token = COMPLEX_STRING_EDGE_TOKEN_TYPES
-          if successor.type == begin_token
+          if successor.type == COMPLEX_STRING_BEGIN_TOKEN
             ends_to_find = 1
-            while ends_to_find > 0
+            while ends_to_find.positive?
               case processed_source.tokens[index].type
-              when begin_token then ends_to_find += 1
-              when end_token then ends_to_find -= 1
+              when COMPLEX_STRING_BEGIN_TOKEN then ends_to_find += 1
+              when COMPLEX_STRING_END_TOKEN then ends_to_find -= 1
               end
               index += 1
             end
@@ -107,7 +116,7 @@ module RuboCop
           case token.type
           when SIMPLE_STRING_TOKEN_TYPE
             true
-          when *COMPLEX_STRING_EDGE_TOKEN_TYPES
+          when COMPLEX_STRING_BEGIN_TOKEN, COMPLEX_STRING_END_TOKEN
             QUOTE_DELIMITERS.include?(token.text)
           else
             false

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

@@ -3,11 +3,44 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks presence of parentheses in method calls containing
-      # parameters. By default, macro methods are ignored. Additional methods
-      # can be added to the `IgnoredMethods` list.
+      # This cop enforces the presence (default) or absence of parentheses in
+      # method calls containing parameters.
       #
-      # @example
+      # In the default style (require_parentheses), macro methods are ignored.
+      # Additional methods can be added to the `IgnoredMethods`
+      # or `IgnoredPatterns` list. These options are
+      # valid only in the default style. Macros can be included by
+      # either setting `IgnoreMacros` to false or adding specific macros to
+      # the `IncludedMacros` list.
+      #
+      # Precedence of options is all follows:
+      #
+      # 1. `IgnoredMethods`
+      # 2. `IgnoredPatterns`
+      # 3. `IncludedMacros`
+      #
+      # eg. If a method is listed in both
+      # `IncludedMacros` and `IgnoredMethods`, then the latter takes
+      # precedence (that is, the method is ignored).
+      #
+      # In the alternative style (omit_parentheses), there are three additional
+      # options.
+      #
+      # 1. `AllowParenthesesInChaining` is `false` by default. Setting it to
+      #    `true` allows the presence of parentheses in the last call during
+      #    method chaining.
+      #
+      # 2. `AllowParenthesesInMultilineCall` is `false` by default. Setting it
+      #     to `true` allows the presence of parentheses in multi-line method
+      #     calls.
+      #
+      # 3. `AllowParenthesesInCamelCaseMethod` is `false` by default. This
+      #     allows the presence of parentheses when calling a method whose name
+      #     begins with a capital letter and which has no arguments. Setting it
+      #     to `true` allows the presence of parentheses in such a method call
+      #     even with arguments.
+      #
+      # @example EnforcedStyle: require_parentheses (default)
       #
       #   # bad
       #   array.delete e
@@ -26,64 +59,132 @@ module RuboCop
       #   # okay with `puts` listed in `IgnoredMethods`
       #   puts 'test'
       #
-      #   # IgnoreMacros: true (default)
+      #   # okay with `^assert` listed in `IgnoredPatterns`
+      #   assert_equal 'test', x
+      #
+      # @example EnforcedStyle: omit_parentheses
+      #
+      #   # bad
+      #   array.delete(e)
+      #
+      #   # good
+      #   array.delete e
+      #
+      #   # bad
+      #   foo.enforce(strict: true)
+      #
+      #   # good
+      #   foo.enforce strict: true
+      #
+      # @example IgnoreMacros: true (default)
       #
       #   # good
       #   class Foo
       #     bar :baz
       #   end
       #
-      #   # IgnoreMacros: false
+      # @example IgnoreMacros: false
       #
       #   # bad
       #   class Foo
       #     bar :baz
       #   end
-      class MethodCallWithArgsParentheses < Cop
-        MSG = 'Use parentheses for method calls with arguments.'.freeze
-
-        def on_send(node)
-          return if ignored_method?(node)
-          return unless node.arguments? && !node.parenthesized?
+      #
+      # @example AllowParenthesesInMultilineCall: false (default)
+      #
+      #   # bad
+      #   foo.enforce(
+      #     strict: true
+      #   )
+      #
+      #   # good
+      #   foo.enforce \
+      #     strict: true
+      #
+      # @example AllowParenthesesInMultilineCall: true
+      #
+      #   # good
+      #   foo.enforce(
+      #     strict: true
+      #   )
+      #
+      #   # good
+      #   foo.enforce \
+      #     strict: true
+      #
+      # @example AllowParenthesesInChaining: false (default)
+      #
+      #   # bad
+      #   foo().bar(1)
+      #
+      #   # good
+      #   foo().bar 1
+      #
+      # @example AllowParenthesesInChaining: true
+      #
+      #   # good
+      #   foo().bar(1)
+      #
+      #   # good
+      #   foo().bar 1
+      #
+      # @example AllowParenthesesInCamelCaseMethod: false (default)
+      #
+      #   # bad
+      #   Array(1)
+      #
+      #   # good
+      #   Array 1
+      #
+      # @example AllowParenthesesInCamelCaseMethod: true
+      #
+      #   # good
+      #   Array(1)
+      #
+      #   # good
+      #   Array 1
+      class MethodCallWithArgsParentheses < Base
+        include ConfigurableEnforcedStyle
+        include IgnoredMethods
+        include IgnoredPattern
+        extend AutoCorrector
 
-          add_offense(node)
-        end
-        alias on_super on_send
-        alias on_yield on_send
+        def initialize(*)
+          super
+          return unless style_configured?
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(args_begin(node), '(')
-            corrector.insert_after(args_end(node), ')')
+          case style
+          when :require_parentheses
+            extend RequireParentheses
+          when :omit_parentheses
+            extend OmitParentheses
           end
         end
 
-        private
-
-        def ignored_method?(node)
-          node.operator_method? || node.setter_method? ||
-            ignore_macros? && node.macro? ||
-            ignored_list.include?(node.method_name)
-        end
+        # @abstract Overridden in style modules
+        def autocorrect(_node); end
 
-        def ignored_list
-          cop_config['IgnoredMethods'].map(&:to_sym)
-        end
-
-        def ignore_macros?
-          cop_config['IgnoreMacros']
-        end
+        private
 
         def args_begin(node)
           loc = node.loc
           selector =
             node.super_type? || node.yield_type? ? loc.keyword : loc.selector
-          selector.end.resize(1)
+
+          resize_by = args_parenthesized?(node) ? 2 : 1
+          selector.end.resize(resize_by)
         end
 
         def args_end(node)
           node.loc.expression.end
         end
+
+        def args_parenthesized?(node)
+          return false unless node.arguments.one?
+
+          first_node = node.arguments.first
+          first_node.begin_type? && first_node.parenthesized_call?
+        end
       end
     end
   end