rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -13,24 +12,35 @@ module RuboCop
       #   # good
       #   something.map(&:upcase)
       class SymbolProc < Cop
-        MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'.freeze
-
-        PROC_NODE = s(:send, s(:const, nil, :Proc), :new)
+        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` ' \
+              'instead of a block.'.freeze
+        SUPER_TYPES = %i[super zsuper].freeze
+
+        def_node_matcher :proc_node?, '(send (const nil? :Proc) :new)'
+        def_node_matcher :symbol_proc?, <<-PATTERN
+          (block
+            ${(send ...) (super ...) zsuper}
+            (args (arg _var))
+            (send (lvar _var) $_))
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [Layout::SpaceBeforeBlockBraces]
+        end
 
         def on_block(node)
-          block_send_or_super, block_args, block_body = *node
-          block_method_name = resolve_block_method_name(block_send_or_super)
-
-          # TODO: Rails-specific handling that we should probably make
-          # configurable - https://github.com/bbatsov/rubocop/issues/1485
-          # we should ignore lambdas & procs
-          return if block_send_or_super == PROC_NODE
-          return if [:lambda, :proc].include?(block_method_name)
-          return if ignored_method?(block_method_name)
-          return unless can_shorten?(block_args, block_body)
-
-          _receiver, method_name, _args = *block_body
-          offense(node, method_name, block_method_name)
+          symbol_proc?(node) do |send_or_super, method|
+            block_method_name = resolve_block_method_name(send_or_super)
+
+            # TODO: Rails-specific handling that we should probably make
+            # configurable - https://github.com/bbatsov/rubocop/issues/1485
+            # we should ignore lambdas & procs
+            return if proc_node?(send_or_super)
+            return if %i[lambda proc].include?(block_method_name)
+            return if ignored_method?(block_method_name)
+
+            offense(node, method, block_method_name)
+          end
         end
 
         def autocorrect(node)
@@ -57,16 +67,15 @@ module RuboCop
         end
 
         def offense(node, method_name, block_method_name)
-          sb = node.source_range.source_buffer
           block_start = node.loc.begin.begin_pos
           block_end = node.loc.end.end_pos
-          range = Parser::Source::Range.new(sb, block_start, block_end)
+          range = range_between(block_start, block_end)
 
           add_offense(node,
-                      range,
-                      format(MSG,
-                             method_name,
-                             block_method_name))
+                      location: range,
+                      message: format(MSG,
+                                      method: method_name,
+                                      block_method: block_method_name))
         end
 
         def autocorrect_method(corrector, node, args, method_name)
@@ -91,11 +100,9 @@ module RuboCop
         end
 
         def block_range_with_space(node)
-          block_range =
-            Parser::Source::Range.new(node.source_range.source_buffer,
-                                      begin_pos_for_replacement(node),
+          block_range = range_between(begin_pos_for_replacement(node),
                                       node.loc.end.end_pos)
-          range_with_surrounding_space(block_range, :left)
+          range_with_surrounding_space(range: block_range, side: :left)
         end
 
         def begin_pos_for_replacement(node)
@@ -117,32 +124,8 @@ module RuboCop
           ignored_methods.include?(name.to_s)
         end
 
-        def can_shorten?(block_args, block_body)
-          # something { |x, y| ... }
-          return false unless block_args.children.size == 1
-          return false if non_shortenable_args?(block_args)
-          return false unless block_body && block_body.type == :send
-
-          receiver, _method_name, args = *block_body
-
-          # method in block must be invoked on a lvar without args
-          return false if args
-          return false unless receiver && receiver.type == :lvar
-
-          block_arg_name, = *block_args.children.first
-          receiver_name, = *receiver
-
-          block_arg_name == receiver_name
-        end
-
         def super?(node)
-          [:super, :zsuper].include?(node.type)
-        end
-
-        def non_shortenable_args?(block_args)
-          # something { |&x| ... }
-          # something { |*x| ... }
-          [:blockarg, :restarg].include?(block_args.children.first.type)
+          SUPER_TYPES.include?(node.type)
         end
       end
     end

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

@@ -1,92 +1,193 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the presence of arentheses around ternary
+      # This cop checks for the presence of parentheses around ternary
       # conditions. It is configurable to enforce inclusion or omission of
-      # parentheses using `EnforcedStyle`.
+      # parentheses using `EnforcedStyle`. Omission is only enforced when
+      # removing the parentheses won't cause a different behavior.
       #
-      # @example
-      #
-      #   EnforcedStyle: require_no_parentheses (deafault)
-      #
-      #   @bad
+      # @example EnforcedStyle: require_no_parentheses (default)
+      #   # bad
       #   foo = (bar?) ? a : b
-      #   foo = (bar.baz) ? a : b
+      #   foo = (bar.baz?) ? a : b
       #   foo = (bar && baz) ? a : b
       #
-      #   @good
+      #   # good
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = bar && baz ? a : b
       #
-      # @example
-      #
-      #   EnforcedStyle: require_parentheses
-      #
-      #   @bad
+      # @example EnforcedStyle: require_parentheses
+      #   # bad
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = bar && baz ? a : b
       #
-      #   @good
+      #   # good
+      #   foo = (bar?) ? a : b
+      #   foo = (bar.baz?) ? a : b
+      #   foo = (bar && baz) ? a : b
+      #
+      # @example EnforcedStyle: require_parentheses_when_complex
+      #   # bad
       #   foo = (bar?) ? a : b
-      #   foo = (bar.baz) ? a : b
+      #   foo = (bar.baz?) ? a : b
+      #   foo = bar && baz ? a : b
+      #
+      #   # good
+      #   foo = bar? ? a : b
+      #   foo = bar.baz? ? a : b
       #   foo = (bar && baz) ? a : b
       class TernaryParentheses < Cop
-        include IfNode
         include SafeAssignment
         include ConfigurableEnforcedStyle
+        include SurroundingSpace
 
-        MSG = '%s parentheses for ternary conditions.'.freeze
+        VARIABLE_TYPES = AST::Node::VARIABLES
+        NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
+
+        MSG = '%<command>s parentheses for ternary conditions.'.freeze
+        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with' \
+          ' complex conditions.'.freeze
 
         def on_if(node)
-          return unless ternary?(node)
+          return unless node.ternary? && !infinite_loop? && offense?(node)
 
-          add_offense(node, node.source_range, message) if offense?(node)
+          add_offense(node, location: node.source_range)
         end
 
-        private
+        def autocorrect(node)
+          condition = node.condition
 
-        def offense?(node)
-          condition, = *node
+          return nil if parenthesized?(condition) &&
+                        (safe_assignment?(condition) ||
+                        unsafe_autocorrect?(condition))
 
-          (require_parentheses? && !parenthesized?(condition) ||
-            !require_parentheses? && parenthesized?(condition)) &&
-            !(safe_assignment?(condition) && safe_assignment_allowed?)
+          if parenthesized?(condition)
+            correct_parenthesized(condition)
+          else
+            correct_unparenthesized(condition)
+          end
         end
 
-        def autocorrect(node)
-          condition, = *node
+        private
 
-          lambda do |corrector|
-            if require_parentheses?
-              corrector.insert_before(condition.source_range, '(')
-              corrector.insert_after(condition.source_range, ')')
+        def offense?(node)
+          condition = node.condition
+
+          if safe_assignment?(condition)
+            !safe_assignment_allowed?
+          else
+            parens = parenthesized?(condition)
+            case style
+            when :require_parentheses_when_complex
+              complex_condition?(condition) ? !parens : parens
             else
-              # Don't correct if it's a safe assignment
-              unless safe_assignment?(condition)
-                corrector.remove(condition.loc.begin)
-                corrector.remove(condition.loc.end)
-              end
+              require_parentheses? ? !parens : parens
             end
           end
         end
 
-        def message
-          verb = require_parentheses? ? 'Use' : 'Omit'
+        # If the condition is parenthesized we recurse and check for any
+        # complex expressions within it.
+        def complex_condition?(condition)
+          if condition.begin_type?
+            condition.to_a.any? { |x| complex_condition?(x) }
+          else
+            non_complex_expression?(condition) ? false : true
+          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)
+        end
+
+        def non_complex_send?(node)
+          return false unless node.send_type?
 
-          format(MSG, verb)
+          !node.operator_method? || node.method?(:[])
+        end
+
+        def message(node)
+          if require_parentheses_when_complex?
+            command = parenthesized?(node.condition) ? 'Only use' : 'Use'
+            format(MSG_COMPLEX, command: command)
+          else
+            command = require_parentheses? ? 'Use' : 'Omit'
+            format(MSG, command: command)
+          end
         end
 
         def require_parentheses?
           style == :require_parentheses
         end
 
+        def require_parentheses_when_complex?
+          style == :require_parentheses_when_complex
+        end
+
+        def redundant_parentheses_enabled?
+          @config.for_cop('Style/RedundantParentheses').fetch('Enabled')
+        end
+
         def parenthesized?(node)
-          node.source =~ /^\(.*\)$/
+          node.begin_type?
+        end
+
+        # When this cop is configured to enforce parentheses and the
+        # `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? &&
+            redundant_parentheses_enabled?
+        end
+
+        def unsafe_autocorrect?(condition)
+          condition.children.any? do |child|
+            unparenthesized_method_call?(child)
+          end
+        end
+
+        def unparenthesized_method_call?(child)
+          argument = method_call_argument(child)
+          argument && argument !~ /^\(/
+        end
+
+        def_node_matcher :method_call_argument, <<-PATTERN
+          {(:defined? $...)
+           (send {_ nil?} _ $(send nil? _)...)}
+        PATTERN
+
+        def correct_parenthesized(condition)
+          lambda do |corrector|
+            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
+        end
+
+        def correct_unparenthesized(condition)
+          lambda do |corrector|
+            corrector.insert_before(condition.source_range, '(')
+            corrector.insert_after(condition.source_range, ')')
+          end
+        end
+
+        def whitespace_after?(node)
+          index = index_of_last_token(node)
+          last_token = processed_source.tokens[index]
+          last_token.space_after?
         end
       end
     end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing code after the method definition.
+      #
+      # @example
+      #   # bad
+      #   def some_method; do_stuff
+      #   end
+      #
+      #   def f(x); b = foo
+      #     b[c: x]
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_stuff
+      #   end
+      #
+      #   def f(x)
+      #     b = foo
+      #     b[c: x]
+      #   end
+      #
+      class TrailingBodyOnMethodDefinition < Cop
+        include Alignment
+
+        MSG = "Place the first line of a multi-line method definition's " \
+              'body on its own line.'.freeze
+
+        def on_def(node)
+          return unless trailing_body?(node)
+
+          add_offense(node, location: first_part_of(node.body))
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          lambda do |corrector|
+            break_line_before_body(node, corrector)
+            move_comment(node, corrector)
+            remove_semicolon(corrector)
+          end
+        end
+
+        private
+
+        def trailing_body?(node)
+          node.body && node.multiline? && on_def_line?(node)
+        end
+
+        def on_def_line?(node)
+          node.source_range.first_line == node.body.source_range.first_line
+        end
+
+        def break_line_before_body(node, corrector)
+          corrector.insert_before(
+            first_part_of(node.body),
+            "\n" + ' ' * (node.loc.keyword.column +
+                          configured_indentation_width)
+          )
+        end
+
+        def first_part_of(body)
+          if body.begin_type?
+            body.children.first.source_range
+          else
+            body.source_range
+          end
+        end
+
+        def move_comment(node, corrector)
+          eol_comment = end_of_line_comment(node.source_range.line)
+          return unless eol_comment
+
+          text = eol_comment.loc.expression.source
+          corrector.insert_before(node.source_range,
+                                  text + "\n" + (' ' * node.loc.keyword.column))
+          corrector.remove(eol_comment.loc.expression)
+        end
+
+        def end_of_line_comment(line)
+          processed_source.comments.find { |c| c.loc.line == line }
+        end
+
+        def remove_semicolon(corrector)
+          return unless semicolon
+          corrector.remove(semicolon.pos)
+        end
+
+        def semicolon
+          @semicolon ||= processed_source.tokens.find do |token|
+            token.line == 1 && token.semicolon?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,23 +5,37 @@ module RuboCop
     module Style
       # This cop checks for trailing comma in argument lists.
       #
-      # @example
-      #   # always bad
+      # @example EnforcedStyleForMultiline: consistent_comma
+      #   # bad
       #   method(1, 2,)
       #
-      #   # good if EnforcedStyleForMultiline is consistent_comma
+      #   # good
       #   method(
       #     1, 2,
       #     3,
       #   )
       #
-      #   # good if EnforcedStyleForMultiline is comma or consistent_comma
+      #   # good
       #   method(
       #     1,
       #     2,
       #   )
       #
-      #   # good if EnforcedStyleForMultiline is no_comma
+      # @example EnforcedStyleForMultiline: comma
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
+      #   method(
+      #     1,
+      #     2,
+      #   )
+      #
+      # @example EnforcedStyleForMultiline: no_comma (default)
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
       #   method(
       #     1,
       #     2
@@ -31,31 +44,29 @@ module RuboCop
         include TrailingComma
 
         def on_send(node)
-          _receiver, _method_name, *args = *node
-          return if args.empty?
-          # It's impossible for a method call without parentheses to have
-          # a trailing comma.
-          return unless brackets?(node)
+          return unless node.arguments? && node.parenthesized?
+
+          check(node, node.arguments, 'parameter of %<article>s method call',
+                node.last_argument.source_range.end_pos,
+                node.source_range.end_pos)
+        end
 
-          check(node, args, 'parameter of %s method call',
-                args.last.source_range.end_pos, node.source_range.end_pos)
+        def autocorrect(range)
+          PunctuationCorrector.swap_comma(range)
         end
 
         private
 
         def avoid_autocorrect?(args)
-          hash_with_braces?(args.last) && braces_will_be_removed?(args)
-        end
-
-        def hash_with_braces?(node)
-          node.hash_type? && node.loc.begin
+          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['Enabled']
+          return false unless brace_config.fetch('Enabled')
           return false if brace_config['AutoCorrect'] == false
 
           brace_style = brace_config['EnforcedStyle']
@@ -63,7 +74,7 @@ module RuboCop
 
           return false unless brace_style == 'context_dependent'
 
-          args.size == 1 || !args[-2].hash_type?
+          args.one? || !args[-2].hash_type?
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,23 +5,37 @@ module RuboCop
     module Style
       # This cop checks for trailing comma in array and hash literals.
       #
-      # @example
-      #   # always bad
+      # @example EnforcedStyleForMultiline: consistent_comma
+      #   # bad
       #   a = [1, 2,]
       #
-      #   # good if EnforcedStyleForMultiline is consistent_comma
+      #   # good
       #   a = [
       #     1, 2,
       #     3,
       #   ]
       #
-      #   # good if EnforcedStyleForMultiline is comma or consistent_comma
+      #   # good
       #   a = [
       #     1,
       #     2,
       #   ]
       #
-      #   # good if EnforcedStyleForMultiline is no_comma
+      # @example EnforcedStyleForMultiline: comma
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      # @example EnforcedStyleForMultiline: no_comma (default)
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
       #   a = [
       #     1,
       #     2
@@ -32,11 +45,16 @@ module RuboCop
         include TrailingComma
 
         def on_array(node)
-          check_literal(node, 'item of %s array') if square_brackets?(node)
+          return unless node.square_brackets?
+          check_literal(node, 'item of %<article>s array')
         end
 
         def on_hash(node)
-          check_literal(node, 'item of %s hash')
+          check_literal(node, 'item of %<article>s hash')
+        end
+
+        def autocorrect(range)
+          PunctuationCorrector.swap_comma(range)
         end
 
         private