rubocop 0.78.0 → 1.13.0

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

@@ -12,19 +12,15 @@ module RuboCop
       #
       #   # good
       #   :symbol
-      class SymbolLiteral < Cop
+      class SymbolLiteral < Base
+        extend AutoCorrector
+
         MSG = 'Do not use strings for word-like symbol literals.'
 
         def on_sym(node)
-          return unless node.source =~ /\A:["'][A-Za-z_]\w*["']\z/
-
-          add_offense(node)
-        end
+          return unless /\A:["'][A-Za-z_]\w*["']\z/.match?(node.source)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, node.source.delete(%q('")))
-          end
+          add_offense(node) { |corrector| corrector.replace(node, node.source.delete(%q('"))) }
         end
       end
     end

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

@@ -5,26 +5,47 @@ module RuboCop
     module Style
       # Use symbols as procs when possible.
       #
+      # If you prefer a style that allows block for method with arguments,
+      # please set `true` to `AllowMethodsWithArguments`.
+      #
       # @example
       #   # bad
       #   something.map { |s| s.upcase }
+      #   something.map { _1.upcase }
       #
       #   # good
       #   something.map(&:upcase)
-      class SymbolProc < Cop
+      #
+      # @example AllowMethodsWithArguments: false (default)
+      #   # bad
+      #   something.do_something(foo) { |o| o.bar }
+      #
+      #   # good
+      #   something.do_something(foo, &:bar)
+      #
+      # @example AllowMethodsWithArguments: true
+      #   # good
+      #   something.do_something(foo) { |o| o.bar }
+      class SymbolProc < Base
         include RangeHelp
         include IgnoredMethods
+        extend AutoCorrector
 
-        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` ' \
-              'instead of a block.'
+        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
         SUPER_TYPES = %i[super zsuper].freeze
 
-        def_node_matcher :proc_node?, '(send (const nil? :Proc) :new)'
+        # @!method proc_node?(node)
+        def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
+
+        # @!method symbol_proc_receiver?(node)
+        def_node_matcher :symbol_proc_receiver?, '{(send ...) (super ...) zsuper}'
+
+        # @!method symbol_proc?(node)
         def_node_matcher :symbol_proc?, <<~PATTERN
-          (block
-            ${(send ...) (super ...) zsuper}
-            $(args (arg _var))
-            (send (lvar _var) $_))
+          {
+            (block $#symbol_proc_receiver? $(args (arg _var)) (send (lvar _var) $_))
+            (numblock $#symbol_proc_receiver? $1 (send (lvar :_1) $_))
+          }
         PATTERN
 
         def self.autocorrect_incompatible_with
@@ -34,64 +55,57 @@ module RuboCop
         def on_block(node)
           symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
             # TODO: Rails-specific handling that we should probably make
-            # configurable - https://github.com/rubocop-hq/rubocop/issues/1485
+            # configurable - https://github.com/rubocop/rubocop/issues/1485
             # we should ignore lambdas & procs
             return if proc_node?(dispatch_node)
             return if %i[lambda proc].include?(dispatch_node.method_name)
             return if ignored_method?(dispatch_node.method_name)
-            return if destructuring_block_argument?(arguments_node)
+            return if allow_if_method_has_argument?(node)
+            return if node.block_type? && destructuring_block_argument?(arguments_node)
 
             register_offense(node, method_name, dispatch_node.method_name)
           end
         end
+        alias on_numblock on_block
 
         def destructuring_block_argument?(argument_node)
           argument_node.one? && argument_node.source.include?(',')
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.send_node.arguments?
-              autocorrect_with_args(corrector, node,
-                                    node.send_node.arguments,
-                                    node.body.method_name)
-            else
-              autocorrect_without_args(corrector, node)
-            end
-          end
-        end
-
         private
 
         def register_offense(node, method_name, block_method_name)
           block_start = node.loc.begin.begin_pos
           block_end = node.loc.end.end_pos
           range = range_between(block_start, block_end)
+          message = format(MSG, method: method_name, block_method: block_method_name)
 
-          add_offense(node,
-                      location: range,
-                      message: format(MSG,
-                                      method: method_name,
-                                      block_method: block_method_name))
+          add_offense(range, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+
+        def autocorrect(corrector, node)
+          if node.send_node.arguments?
+            autocorrect_with_args(corrector, node, node.send_node.arguments, node.body.method_name)
+          else
+            autocorrect_without_args(corrector, node)
+          end
         end
 
         def autocorrect_without_args(corrector, node)
-          corrector.replace(block_range_with_space(node),
-                            "(&:#{node.body.method_name})")
+          corrector.replace(block_range_with_space(node), "(&:#{node.body.method_name})")
         end
 
         def autocorrect_with_args(corrector, node, args, method_name)
           arg_range = args.last.source_range
           arg_range = range_with_surrounding_comma(arg_range, :right)
           replacement = " &:#{method_name}"
-          replacement = ',' + replacement unless arg_range.source.end_with?(',')
+          replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
           corrector.insert_after(arg_range, replacement)
           corrector.remove(block_range_with_space(node))
         end
 
         def block_range_with_space(node)
-          block_range = range_between(begin_pos_for_replacement(node),
-                                      node.loc.end.end_pos)
+          block_range = range_between(begin_pos_for_replacement(node), node.loc.end.end_pos)
           range_with_surrounding_space(range: block_range, side: :left)
         end
 
@@ -104,6 +118,10 @@ module RuboCop
             node.loc.begin.begin_pos
           end
         end
+
+        def allow_if_method_has_argument?(node)
+          !!cop_config.fetch('AllowMethodsWithArguments', false) && !node.arguments.count.zero?
+        end
       end
     end
   end

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

@@ -54,45 +54,48 @@ module RuboCop
       #   # bad
       #   foo = (bar = baz) ? a : b
       #
-      class TernaryParentheses < Cop
+      class TernaryParentheses < Base
         include SafeAssignment
         include ConfigurableEnforcedStyle
         include SurroundingSpace
+        extend AutoCorrector
 
         VARIABLE_TYPES = AST::Node::VARIABLES
         NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
 
         MSG = '%<command>s parentheses for ternary conditions.'
-        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with' \
-          ' complex conditions.'
+        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with complex conditions.'
 
         def on_if(node)
           return if only_closing_parenthesis_is_last_line?(node.condition)
           return unless node.ternary? && !infinite_loop? && offense?(node)
 
-          add_offense(node, location: node.source_range)
+          message = message(node)
+
+          add_offense(node.source_range, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def only_closing_parenthesis_is_last_line?(condition)
           condition.source.split("\n").last == ')'
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           condition = node.condition
 
           return nil if parenthesized?(condition) &&
-                        (safe_assignment?(condition) ||
-                        unsafe_autocorrect?(condition))
+                        (safe_assignment?(condition) || unsafe_autocorrect?(condition))
 
           if parenthesized?(condition)
-            correct_parenthesized(condition)
+            correct_parenthesized(corrector, condition)
           else
-            correct_unparenthesized(condition)
+            correct_unparenthesized(corrector, condition)
           end
         end
 
-        private
-
         def offense?(node)
           condition = node.condition
 
@@ -115,15 +118,14 @@ module RuboCop
           if condition.begin_type?
             condition.to_a.any? { |x| complex_condition?(x) }
           else
-            non_complex_expression?(condition) ? false : true
+            !non_complex_expression?(condition)
           end
         end
 
         # Anything that is not a variable, constant, or method/.method call
         # will be counted as a complex expression.
         def non_complex_expression?(condition)
-          NON_COMPLEX_TYPES.include?(condition.type) ||
-            non_complex_send?(condition)
+          NON_COMPLEX_TYPES.include?(condition.type) || non_complex_send?(condition)
         end
 
         def non_complex_send?(node)
@@ -162,7 +164,7 @@ module RuboCop
         # `RedundantParentheses` cop is enabled, it will cause an infinite loop
         # as they compete to add and remove the parentheses respectively.
         def infinite_loop?
-          require_parentheses? &&
+          (require_parentheses? || require_parentheses_when_complex?) &&
             redundant_parentheses_enabled?
         end
 
@@ -174,7 +176,7 @@ module RuboCop
         end
 
         def unparenthesized_method_call?(child)
-          method_name(child) =~ /^[a-z]/i && !child.parenthesized?
+          /^[a-z]/i.match?(method_name(child)) && !child.parenthesized?
         end
 
         def below_ternary_precedence?(child)
@@ -186,35 +188,28 @@ module RuboCop
             (child.send_type? && child.prefix_not?)
         end
 
+        # @!method method_name(node)
         def_node_matcher :method_name, <<~PATTERN
-          {($:defined? (send nil? _) ...)
+          {($:defined? _ ...)
            (send {_ nil?} $_ _ ...)}
         PATTERN
 
-        def correct_parenthesized(condition)
-          lambda do |corrector|
-            corrector.remove(condition.loc.begin)
-            corrector.remove(condition.loc.end)
+        def correct_parenthesized(corrector, condition)
+          corrector.remove(condition.loc.begin)
+          corrector.remove(condition.loc.end)
 
-            # Ruby allows no space between the question mark and parentheses.
-            # If we remove the parentheses, we need to add a space or we'll
-            # generate invalid code.
-            unless whitespace_after?(condition)
-              corrector.insert_after(condition.loc.end, ' ')
-            end
-          end
+          # Ruby allows no space between the question mark and parentheses.
+          # If we remove the parentheses, we need to add a space or we'll
+          # generate invalid code.
+          corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
         end
 
-        def correct_unparenthesized(condition)
-          lambda do |corrector|
-            corrector.insert_before(condition.source_range, '(')
-            corrector.insert_after(condition.source_range, ')')
-          end
+        def correct_unparenthesized(corrector, condition)
+          corrector.wrap(condition, '(', ')')
         end
 
         def whitespace_after?(node)
-          index = index_of_last_token(node)
-          last_token = processed_source.tokens[index]
+          last_token = processed_source.last_token_of(node)
           last_token.space_after?
         end
       end

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

@@ -15,20 +15,17 @@ module RuboCop
       #     def foo; end
       #   end
       #
-      class TrailingBodyOnClass < Cop
+      class TrailingBodyOnClass < Base
         include Alignment
         include TrailingBody
+        extend AutoCorrector
 
         MSG = 'Place the first line of class body on its own line.'
 
         def on_class(node)
           return unless trailing_body?(node)
 
-          add_offense(node, location: first_part_of(node.to_a.last))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(first_part_of(node.to_a.last)) do |corrector|
             LineBreakCorrector.correct_trailing_body(
               configured_width: configured_indentation_width,
               corrector: corrector,

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

@@ -5,6 +5,8 @@ module RuboCop
     module Style
       # This cop checks for trailing code after the method definition.
       #
+      # NOTE: It always accepts endless method definitions that are basically on the same line.
+      #
       # @example
       #   # bad
       #   def some_method; do_stuff
@@ -24,22 +26,20 @@ module RuboCop
       #     b[c: x]
       #   end
       #
-      class TrailingBodyOnMethodDefinition < Cop
+      #   def endless_method = do_stuff
+      #
+      class TrailingBodyOnMethodDefinition < Base
         include Alignment
         include TrailingBody
+        extend AutoCorrector
 
-        MSG = "Place the first line of a multi-line method definition's " \
-              'body on its own line.'
+        MSG = "Place the first line of a multi-line method definition's body on its own line."
 
         def on_def(node)
           return unless trailing_body?(node)
+          return if node.endless?
 
-          add_offense(node, location: first_part_of(node.body))
-        end
-        alias on_defs on_def
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(first_part_of(node.body)) do |corrector|
             LineBreakCorrector.correct_trailing_body(
               configured_width: configured_indentation_width,
               corrector: corrector,
@@ -48,6 +48,7 @@ module RuboCop
             )
           end
         end
+        alias on_defs on_def
       end
     end
   end

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

@@ -15,20 +15,17 @@ module RuboCop
       #     extend self
       #   end
       #
-      class TrailingBodyOnModule < Cop
+      class TrailingBodyOnModule < Base
         include Alignment
         include TrailingBody
+        extend AutoCorrector
 
         MSG = 'Place the first line of module body on its own line.'
 
         def on_module(node)
           return unless trailing_body?(node)
 
-          add_offense(node, location: first_part_of(node.to_a.last))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(first_part_of(node.to_a.last)) do |corrector|
             LineBreakCorrector.correct_trailing_body(
               configured_width: configured_indentation_width,
               corrector: corrector,

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

@@ -4,6 +4,14 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for trailing comma in argument lists.
+      # The supported styles are:
+      #
+      # * `consistent_comma`: Requires a comma after the last argument,
+      # for all parenthesized method calls with arguments.
+      # * `comma`: Requires a comma after the last argument, but only for
+      # parenthesized method calls where each argument is on its own line.
+      # * `no_comma`: Requires that there is no comma after the last
+      # argument.
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
@@ -20,6 +28,11 @@ module RuboCop
       #
       #   # good
       #   method(
+      #     1, 2, 3,
+      #   )
+      #
+      #   # good
+      #   method(
       #     1,
       #     2,
       #   )
@@ -31,6 +44,28 @@ module RuboCop
       #   # good
       #   method(1, 2)
       #
+      #   # bad
+      #   method(
+      #     1, 2,
+      #     3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1, 2,
+      #     3
+      #   )
+      #
+      #   # bad
+      #   method(
+      #     1, 2, 3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1, 2, 3
+      #   )
+      #
       #   # good
       #   method(
       #     1,
@@ -49,8 +84,9 @@ module RuboCop
       #     1,
       #     2
       #   )
-      class TrailingCommaInArguments < Cop
+      class TrailingCommaInArguments < Base
         include TrailingComma
+        extend AutoCorrector
 
         def on_send(node)
           return unless node.arguments? && node.parenthesized?
@@ -61,35 +97,9 @@ module RuboCop
         end
         alias on_csend on_send
 
-        def autocorrect(range)
-          PunctuationCorrector.swap_comma(range)
-        end
-
         def self.autocorrect_incompatible_with
           [Layout::HeredocArgumentClosingParenthesis]
         end
-
-        private
-
-        def avoid_autocorrect?(args)
-          args.last.hash_type? && args.last.braces? &&
-            braces_will_be_removed?(args)
-        end
-
-        # Returns true if running with --auto-correct would remove the braces
-        # of the last argument.
-        def braces_will_be_removed?(args)
-          brace_config = config.for_cop('Style/BracesAroundHashParameters')
-          return false unless brace_config.fetch('Enabled')
-          return false if brace_config['AutoCorrect'] == false
-
-          brace_style = brace_config['EnforcedStyle']
-          return true if brace_style == 'no_braces'
-
-          return false unless brace_style == 'context_dependent'
-
-          args.one? || !args[-2].hash_type?
-        end
       end
     end
   end