rubocop 0.47.1 → 0.48.0

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

@@ -16,10 +16,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         def on_send(node)
-          _receiver, selector, = *node
-
-          # we care only about `call` methods
-          return unless selector == :call
+          return unless node.receiver && node.method?(:call)
 
           if offense?(node)
             add_offense(node, :expression) { opposite_style_detected }
@@ -31,17 +28,16 @@ module RuboCop
         private
 
         def offense?(node)
-          # lambda.() does not have a selector
-          style == :call && node.loc.selector.nil? ||
-            style == :braces && node.loc.selector
+          explicit_style? && node.implicit_call? ||
+            implicit_style? && !node.implicit_call?
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            if style == :call
-              receiver_node, = *node
-              receiver = receiver_node.source
+            if explicit_style?
+              receiver = node.receiver.source
               replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
+
               corrector.replace(node.source_range, replacement)
             else
               corrector.remove(node.loc.selector)
@@ -50,12 +46,20 @@ module RuboCop
         end
 
         def message(_node)
-          if style == :call
+          if explicit_style?
             'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'
           else
             'Prefer the use of `lambda.(...)` over `lambda.call(...)`.'
           end
         end
+
+        def implicit_style?
+          style == :braces
+        end
+
+        def explicit_style?
+          style == :call
+        end
       end
     end
   end

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

@@ -22,11 +22,11 @@ module RuboCop
       class LineEndConcatenation < Cop
         MSG = 'Use `\\` instead of `+` or `<<` to concatenate ' \
               'those strings.'.freeze
-        CONCAT_TOKEN_TYPES = [:tPLUS, :tLSHFT].freeze
+        CONCAT_TOKEN_TYPES = %i(tPLUS tLSHFT).freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
-        COMPLEX_STRING_EDGE_TOKEN_TYPES = [:tSTRING_BEG, :tSTRING_END].freeze
-        HIGH_PRECEDENCE_OP_TOKEN_TYPES = [:tSTAR2, :tPERCENT, :tDOT,
-                                          :tLBRACK2].freeze
+        COMPLEX_STRING_EDGE_TOKEN_TYPES = %i(tSTRING_BEG tSTRING_END).freeze
+        HIGH_PRECEDENCE_OP_TOKEN_TYPES = %i(tSTAR2 tPERCENT tDOT
+                                            tLBRACK2).freeze
         QUOTE_DELIMITERS = %w(' ").freeze
 
         def investigate(processed_source)

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

@@ -4,29 +4,41 @@ module RuboCop
   module Cop
     module Style
       # This cop checks presence of parentheses in method calls containing
-      # parameters.
-      # As in popular Ruby's frameworks a lot of methods should always be
-      # called without parentheses,
-      # users can ignore them by passing their names to IgnoredMethods option.
+      # parameters. By default, macro methods are ignored. Additional methods
+      # can be added to the `IgnoredMethods` list.
       #
       # @example
+      #
       #   # bad
       #   array.delete e
       #
       #   # good
       #   array.delete(e)
       #
-      #   # good if `puts` is listed in IgnoredMethods
+      #   # okay with `puts` listed in `IgnoredMethods`
       #   puts 'test'
+      #
+      #   # IgnoreMacros: true (default)
+      #
+      #   # good
+      #   class Foo
+      #     bar :baz
+      #   end
+      #
+      #   # IgnoreMacros: false
+      #
+      #   # bad
+      #   class Foo
+      #     bar :baz
+      #   end
       class MethodCallWithArgsParentheses < Cop
         MSG = 'Use parentheses for method calls with arguments.'.freeze
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return if ignored_list.include?(method_name)
-          return if args.empty?
+          return if ignored_list.include?(node.method_name)
+          return unless node.arguments? && !node.parenthesized?
           return if operator_call?(node)
-          return if parentheses?(node)
+          return if ignore_macros? && node.macro?
 
           add_offense(node, :selector)
         end
@@ -59,16 +71,16 @@ module RuboCop
           cop_config['IgnoredMethods'].map(&:to_sym)
         end
 
+        def ignore_macros?
+          cop_config['IgnoreMacros']
+        end
+
         def parentheses?(node)
           node.loc.begin
         end
 
         def operator_call?(node)
-          node.loc.operator || (reciever?(node) && !node.loc.dot)
-        end
-
-        def reciever?(node)
-          !node.children[0].nil?
+          node.operator_method?
         end
 
         def args_begin(node)

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

@@ -15,16 +15,13 @@ module RuboCop
         MSG = 'Do not use parentheses for method calls with ' \
               'no arguments.'.freeze
 
-        ASGN_NODES = [:lvasgn, :masgn] + SHORTHAND_ASGN_NODES
+        ASGN_NODES = %i(lvasgn masgn) + SHORTHAND_ASGN_NODES
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-
-          # methods starting with a capital letter should be skipped
-          return if method_name =~ /\A[A-Z]/
-          return unless args.empty? && node.loc.begin
+          return if node.camel_case_method?
+          return unless !node.arguments? && node.parenthesized?
           return if same_name_assignment?(node)
-          return if lambda_call_syntax?(node)
+          return if node.implicit_call?
           return if node.keyword_not?
 
           add_offense(node, :begin)
@@ -40,14 +37,12 @@ module RuboCop
         private
 
         def same_name_assignment?(node)
-          _receiver, method_name, *_args = *node
-
           any_assignment?(node) do |asgn_node|
             if asgn_node.masgn_type?
-              next variable_in_mass_assignment?(method_name, asgn_node)
+              next variable_in_mass_assignment?(node.method_name, asgn_node)
             end
 
-            asgn_node.loc.name.source == method_name.to_s
+            asgn_node.loc.name.source == node.method_name.to_s
           end
         end
 
@@ -74,11 +69,6 @@ module RuboCop
 
           var_nodes.map { |n| n.to_a.first }.include?(variable_name)
         end
-
-        # don't check `lambda.()` syntax; the Style/LambdaCall cop does that
-        def lambda_call_syntax?(node)
-          node.method_name == :call && node.loc.selector.nil?
-        end
       end
     end
   end

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

@@ -27,12 +27,15 @@ module RuboCop
 
         def on_send(node)
           return if ignored_node?(node)
-          receiver, _method_name, *_args = *node
+
+          receiver = node.receiver
+
           return unless receiver && receiver.block_type? &&
                         receiver.loc.end.is?('end')
 
           range = range_between(receiver.loc.end.begin_pos,
                                 node.source_range.end_pos)
+
           add_offense(nil, range)
         end
       end

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

@@ -75,7 +75,7 @@ module RuboCop
         end
 
         def unless_else_cop_enabled?
-          unless_else_config['Enabled'] if unless_else_config
+          unless_else_config.fetch('Enabled')
         end
 
         def unless_else_config
@@ -83,11 +83,12 @@ module RuboCop
         end
 
         def empty_else_cop_enabled?
-          empty_else_config['Enabled'] if empty_else_config
+          empty_else_config.fetch('Enabled')
         end
 
         def empty_else_style
-          empty_else_config['EnforcedStyle'].to_sym if empty_else_config
+          return unless empty_else_config.key?('EnforcedStyle')
+          empty_else_config['EnforcedStyle'].to_sym
         end
 
         def empty_else_config

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for grouping of mixins in `class` and `module` bodies.
+      # By default it enforces mixins to be placed in separate declarations,
+      # but it can be configured to enforce grouping them in one declaration.
+      #
+      # @example
+      #
+      #   EnforcedStyle: separated (default)
+      #
+      #   @bad
+      #   class Foo
+      #     include Bar, Qox
+      #   end
+      #
+      #   @good
+      #   class Foo
+      #     include Qox
+      #     include Bar
+      #   end
+      #
+      #   EnforcedStyle: grouped
+      #
+      #   @bad
+      #   class Foo
+      #     extend Bar
+      #     extend Qox
+      #   end
+      #
+      #   @good
+      #   class Foo
+      #     extend Qox, Bar
+      #   end
+      class MixinGrouping < Cop
+        include ConfigurableEnforcedStyle
+
+        MIXIN_METHODS = %i(extend include prepend).freeze
+        MSG = 'Put `%s` mixins in %s.'.freeze
+
+        def on_send(node)
+          return unless MIXIN_METHODS.include?(node.method_name)
+
+          check(node)
+        end
+
+        private
+
+        def check(send_node)
+          if separated_style?
+            check_separated_style(send_node)
+          else
+            check_grouped_style(send_node)
+          end
+        end
+
+        def check_grouped_style(send_node)
+          return unless sibling_mixins?(send_node)
+
+          add_offense(send_node, :expression)
+        end
+
+        def check_separated_style(send_node)
+          return if send_node.arguments.one?
+
+          add_offense(send_node, :expression)
+        end
+
+        def sibling_mixins?(send_node)
+          siblings = send_node.parent.each_child_node(:send)
+                              .reject { |sibling| sibling == send_node }
+
+          siblings.any? do |sibling_node|
+            sibling_node.method_name == send_node.method_name
+          end
+        end
+
+        def message(send_node)
+          suffix =
+            separated_style? ? 'separate statements' : 'a single statement'
+
+          format(MSG, send_node.method_name, suffix)
+        end
+
+        def grouped_style?
+          style == :grouped
+        end
+
+        def separated_style?
+          style == :separated
+        end
+      end
+    end
+  end
+end

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

@@ -3,11 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that multiline memoizations are wrapped in a `begin`
-      # and `end` block.
+      # This cop checks expressions wrapping styles for multiline memoization.
       #
       # @example
       #
+      #   # EnforcedStyle: keyword (default)
+      #
       #   @bad
       #   foo ||= (
       #     bar
@@ -19,13 +20,31 @@ module RuboCop
       #     bar
       #     baz
       #   end
+      #
+      # @example
+      #
+      #   # EnforcedStyle: braces
+      #
+      #   @bad
+      #   foo ||= begin
+      #     bar
+      #     baz
+      #   end
+      #
+      #   @good
+      #   foo ||= (
+      #     bar
+      #     baz
+      #   )
       class MultilineMemoization < Cop
+        include ConfigurableEnforcedStyle
+
         MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'.freeze
 
         def on_or_asgn(node)
           _lhs, rhs = *node
 
-          return unless rhs.multiline? && rhs.begin_type?
+          return unless bad_rhs?(rhs)
 
           add_offense(rhs, node.source_range, MSG)
         end
@@ -34,8 +53,22 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.loc.begin, 'begin')
-            corrector.replace(node.loc.end, 'end')
+            if style == :keyword
+              corrector.replace(node.loc.begin, 'begin')
+              corrector.replace(node.loc.end, 'end')
+            else
+              corrector.replace(node.loc.begin, '(')
+              corrector.replace(node.loc.end, ')')
+            end
+          end
+        end
+
+        def bad_rhs?(rhs)
+          return false unless rhs.multiline?
+          if style == :keyword
+            rhs.begin_type?
+          else
+            rhs.kwbegin_type?
           end
         end
       end

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

@@ -79,9 +79,7 @@ module RuboCop
         private
 
         def children(node)
-          _receiver, _method_name, *args = *node
-
-          args
+          node.arguments
         end
 
         def ignored_literal?(node)
@@ -90,6 +88,7 @@ module RuboCop
 
         def single_line_ignoring_receiver?(node)
           return false unless node.loc.begin && node.loc.end
+
           node.loc.begin.line == node.loc.end.line
         end
       end

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

@@ -8,15 +8,15 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   while a
+      #   while myvariable
       #   .b
-      #     something
+      #     # do something
       #   end
       #
       #   # good, EnforcedStyle: aligned
-      #   while a
+      #   while myvariable
       #         .b
-      #     something
+      #     # do something
       #   end
       #
       #   # good, EnforcedStyle: aligned
@@ -24,11 +24,29 @@ module RuboCop
       #        .b
       #        .c
       #
-      #   # good, EnforcedStyle: indented
-      #   while a
-      #       .b
-      #     something
+      #   # good, EnforcedStyle:    indented,
+      #           IndentationWidth: 2
+      #   while myvariable
+      #     .b
+      #
+      #     # do something
+      #   end
+      #
+      #   # good, EnforcedStyle:    indented_relative_to_receiver,
+      #           IndentationWidth: 2
+      #   while myvariable
+      #           .a
+      #           .b
+      #
+      #     # do something
       #   end
+      #
+      #   # good, EnforcedStyle:    indented_relative_to_receiver,
+      #           IndentationWidth: 2
+      #   myvariable = Thing
+      #                  .a
+      #                  .b
+      #                  .c
       class MultilineMethodCallIndentation < Cop
         include ConfigurableEnforcedStyle
         include AutocorrectAlignment
@@ -112,15 +130,15 @@ module RuboCop
         end
 
         def alignment_base(node, rhs, given_style)
-          return nil if given_style == :indented
-
-          if given_style == :indented_relative_to_receiver
-            receiver_base = receiver_alignment_base(node)
-            return receiver_base if receiver_base
+          case given_style
+          when :aligned
+            semantic_alignment_base(node, rhs) ||
+              syntactic_alignment_base(node, rhs)
+          when :indented
+            nil
+          when :indented_relative_to_receiver
+            receiver_alignment_base(node)
           end
-
-          semantic_alignment_base(node, rhs) ||
-            syntactic_alignment_base(node, rhs)
         end
 
         def syntactic_alignment_base(lhs, rhs)
@@ -162,10 +180,11 @@ module RuboCop
         #   .b
         #   .c
         def receiver_alignment_base(node)
-          node = semantic_alignment_node(node)
-          return unless node
+          node = node.receiver while node.receiver
+          node = node.parent
+          node = node.parent until node.loc.dot
 
-          node.receiver.source_range
+          node.receiver.source_range if node
         end
 
         def semantic_alignment_node(node)