rubocop 0.52.0 → 0.52.1

data/lib/rubocop/cop/rails/lexically_scoped_action_filter.rb

@@ -34,7 +34,7 @@ module RuboCop
       #     end
       #   end
       class LexicallyScopedActionFilter < Cop
-        MSG = '%s not explicitly defined on the controller.'.freeze
+        MSG = '%<action>s not explicitly defined on the controller.'.freeze
 
         FILTERS = %w[
           :after_action
@@ -101,9 +101,9 @@ module RuboCop
 
         def message(methods)
           if methods.size == 1
-            format(MSG, "`#{methods[0]}` is")
+            format(MSG, action: "`#{methods[0]}` is")
           else
-            format(MSG, "`#{methods.join('`, `')}` are")
+            format(MSG, action: "`#{methods.join('`, `')}` are")
           end
         end
       end

data/lib/rubocop/cop/rails/pluralization_grammar.rb

@@ -26,7 +26,7 @@ module RuboCop
 
         PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert.freeze
 
-        MSG = 'Prefer `%s.%s`.'.freeze
+        MSG = 'Prefer `%<number>s.%<correct>s`.'.freeze
 
         def on_send(node)
           return unless duration_method?(node.method_name)
@@ -50,7 +50,8 @@ module RuboCop
         def message(node)
           number, = *node.receiver
 
-          format(MSG, number, correct_method(node.method_name.to_s))
+          format(MSG, number: number,
+                      correct: correct_method(node.method_name.to_s))
         end
 
         def correct_method(method_name)

data/lib/rubocop/cop/rails/presence.rb

@@ -45,11 +45,11 @@ module RuboCop
             (if
               (send $_recv :present?)
               _recv
-              $_false
+              $!begin
             )
             (if
               (send $_recv :blank?)
-              $_true
+              $!begin
               _recv
             )
           }
@@ -59,44 +59,57 @@ module RuboCop
           {
             (if
               (send (send $_recv :present?) :!)
-              $_true
+              $!begin
               _recv
             )
             (if
               (send (send $_recv :blank?) :!)
               _recv
-              $_false
+              $!begin
             )
           }
         PATTERN
 
         def on_if(node)
-          receiver, other = redundant_receiver_and_other(node)
-          unless receiver
-            receiver, other = redundant_negative_receiver_and_other(node)
+          redundant_receiver_and_other(node) do |receiver, other|
+            unless ignore_other_node?(other)
+              add_offense(node, message: message(node, receiver, other))
+            end
+          end
+
+          redundant_negative_receiver_and_other(node) do |receiver, other|
+            unless ignore_other_node?(other)
+              add_offense(node, message: message(node, receiver, other))
+            end
           end
-          return unless receiver
-          message = format(MSG,
-                           prefer: replacement(receiver, other),
-                           current: node.source)
-          add_offense(node, message: message)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            receiver, other = redundant_receiver_and_other(node)
-            unless receiver
-              receiver, other = redundant_negative_receiver_and_other(node)
+            redundant_receiver_and_other(node) do |receiver, other|
+              corrector.replace(node.source_range, replacement(receiver, other))
+            end
+
+            redundant_negative_receiver_and_other(node) do |receiver, other|
+              corrector.replace(node.source_range, replacement(receiver, other))
             end
-            return unless receiver
-            corrector.replace(node.source_range, replacement(receiver, other))
           end
         end
 
         private
 
+        def ignore_other_node?(node)
+          node && (node.if_type? || node.rescue_type? || node.while_type?)
+        end
+
+        def message(node, receiver, other)
+          format(MSG,
+                 prefer: replacement(receiver, other),
+                 current: node.source)
+        end
+
         def replacement(receiver, other)
-          or_source = other.nil_type? ? '' : " || #{other.source}"
+          or_source = other.nil? || other.nil_type? ? '' : " || #{other.source}"
           "#{receiver.source}.presence" + or_source
         end
       end

data/lib/rubocop/cop/rails/present.rb

@@ -35,9 +35,11 @@ module RuboCop
       #     # good
       #     something if  foo.present?
       class Present < Cop
-        MSG_NOT_BLANK = 'Use `%s` instead of `%s`.'.freeze
-        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%s` instead of `%s`.'.freeze
-        MSG_UNLESS_BLANK = 'Use `if %s` instead of `%s`.'.freeze
+        MSG_NOT_BLANK = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
+        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%<prefer>s` instead of ' \
+                                   '`%<current>s`.'.freeze
+        MSG_UNLESS_BLANK = 'Use `if %<prefer>s` instead of ' \
+                           '`%<current>s`.'.freeze
 
         def_node_matcher :exists_and_not_empty?, <<-PATTERN
           (and
@@ -65,8 +67,8 @@ module RuboCop
           not_blank?(node) do |receiver|
             add_offense(node,
                         message: format(MSG_NOT_BLANK,
-                                        replacement(receiver),
-                                        node.source))
+                                        prefer: replacement(receiver),
+                                        current: node.source))
           end
         end
 
@@ -78,8 +80,8 @@ module RuboCop
 
             add_offense(node,
                         message: format(MSG_EXISTS_AND_NOT_EMPTY,
-                                        replacement(variable1),
-                                        node.source))
+                                        prefer: replacement(variable1),
+                                        current: node.source))
           end
         end
 
@@ -99,7 +101,8 @@ module RuboCop
 
           unless_blank?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)
-            msg = format(MSG_UNLESS_BLANK, replacement(receiver), range.source)
+            msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver),
+                                           current: range.source)
             add_offense(node, location: range, message: msg)
           end
         end

data/lib/rubocop/cop/rails/redundant_receiver_in_with_options.rb

@@ -26,6 +26,34 @@ module RuboCop
       #       has_many :expenses
       #     end
       #   end
+      #
+      # @example
+      #   # bad
+      #   with_options options: false do |merger|
+      #     merger.invoke(merger.something)
+      #   end
+      #
+      #   # good
+      #   with_options options: false do
+      #     invoke(something)
+      #   end
+      #
+      #   # good
+      #   client = Client.new
+      #   with_options options: false do |merger|
+      #     client.invoke(merger.something, something)
+      #   end
+      #
+      #   # ok
+      #   # When `with_options` includes a block, all scoping scenarios
+      #   # cannot be evaluated. Thus, it is ok to include the explicit
+      #   # receiver.
+      #   with_options options: false do |merger|
+      #     merger.invoke
+      #     with_another_method do |another_receiver|
+      #       merger.invoke(another_receiver)
+      #     end
+      #   end
       class RedundantReceiverInWithOptions < Cop
         extend TargetRailsVersion
 
@@ -38,26 +66,35 @@ module RuboCop
             (send nil? :with_options
               (...))
             (args
-              (...))
-            ...)
+              $_arg)
+            $_body)
         PATTERN
 
-        def_node_search :assoc_has_redundant_receiver, <<-PATTERN
-          (send
-            (lvar _) ...)
+        def_node_search :all_block_nodes_in, <<-PATTERN
+          (block ...)
+        PATTERN
+
+        def_node_search :all_send_nodes_in, <<-PATTERN
+          (send ...)
         PATTERN
 
         def on_block(node)
-          with_options?(node) do
-            assoc_has_redundant_receiver(node).each do |assoc|
-              add_offense(assoc, location: assoc.receiver.loc.expression)
+          with_options?(node) do |arg, body|
+            return unless all_block_nodes_in(body).count.zero?
+            send_nodes = all_send_nodes_in(body)
+
+            if send_nodes.all? { |n| same_value?(arg, n.receiver) }
+              send_nodes.each do |send_node|
+                receiver = send_node.receiver
+                add_offense(send_node, location: receiver.source_range)
+              end
             end
           end
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.remove(node.receiver.loc.expression)
+            corrector.remove(node.receiver.source_range)
             corrector.remove(node.loc.dot)
             corrector.remove(block_argument_range(node))
           end
@@ -66,7 +103,8 @@ module RuboCop
         private
 
         def block_argument_range(node)
-          block_argument = node.parent.parent.children[1].loc.expression
+          block_node = node.each_ancestor(:block).first
+          block_argument = block_node.children[1].source_range
 
           range_between(
             search_begin_pos_of_space_before_block_argument(
@@ -85,6 +123,10 @@ module RuboCop
             begin_pos
           end
         end
+
+        def same_value?(arg_node, recv_node)
+          recv_node && recv_node.children[0] == arg_node.children[0]
+        end
       end
     end
   end

data/lib/rubocop/cop/rails/request_referer.rb

@@ -6,15 +6,14 @@ module RuboCop
       # This cop checks for consistent uses of `request.referer` or
       # `request.referrer`, depending on the cop's configuration.
       #
-      # @example
-      #   # EnforcedStyle: referer
+      # @example EnforcedStyle: referer (default)
       #   # bad
       #   request.referrer
       #
       #   # good
       #   request.referer
       #
-      #   # EnforcedStyle: referrer
+      # @example EnforcedStyle: referrer
       #   # bad
       #   request.referer
       #

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

@@ -29,8 +29,7 @@ module RuboCop
 
             next if node.receiver != target_receiver
             next if node.method_name != target_method
-            next if node.parent && node.parent.block_type?
-            next if node.block_argument?
+            next if cleanup?(node)
 
             add_offense(node,
                         message: format(MSG,
@@ -38,6 +37,14 @@ module RuboCop
                                         method: target_method))
           end
         end
+
+        private
+
+        def cleanup?(node)
+          parent = node.parent
+          node.block_argument? ||
+            (parent && (parent.block_type? || !parent.lvasgn_type?))
+        end
       end
     end
   end

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

@@ -125,24 +125,52 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def remove_braces_with_whitespace(corrector, node, space)
           right_brace_and_space = right_brace_and_space(node.loc.end, space)
 
           if comment_on_line?(right_brace_and_space.line)
-            # Removing a line break between a comment and the closing
-            # parenthesis would cause a syntax error, so we only remove the
-            # braces in that case.
             remove_braces(corrector, node)
+          elsif node.multiline?
+            remove_braces_with_range(corrector,
+                                     left_whole_line_range(node.loc.begin),
+                                     right_whole_line_range(node.loc.end))
           else
-            left_brace_and_space =
-              range_with_surrounding_space(range: node.loc.begin,
-                                           side: :right,
-                                           newlines: space[:newlines],
-                                           whitespace: space[:left])
-            corrector.remove(left_brace_and_space)
-            corrector.remove(right_brace_and_space)
+            left_brace_and_space = left_brace_and_space(node.loc.begin, space)
+            remove_braces_with_range(corrector,
+                                     left_brace_and_space,
+                                     right_brace_and_space)
           end
         end
+        # rubocop:enable Metrics/AbcSize
+
+        def remove_braces_with_range(corrector, left_range, right_range)
+          corrector.remove(left_range)
+          corrector.remove(right_range)
+        end
+
+        def left_whole_line_range(loc_begin)
+          if range_by_whole_lines(loc_begin).source.strip == '{'
+            range_by_whole_lines(loc_begin, include_final_newline: true)
+          else
+            loc_begin
+          end
+        end
+
+        def right_whole_line_range(loc_end)
+          if range_by_whole_lines(loc_end).source.strip == '}'
+            range_by_whole_lines(loc_end, include_final_newline: true)
+          else
+            loc_end
+          end
+        end
+
+        def left_brace_and_space(loc_begin, space)
+          range_with_surrounding_space(range: loc_begin,
+                                       side: :right,
+                                       newlines: space[:newlines],
+                                       whitespace: space[:left])
+        end
 
         def right_brace_and_space(loc_end, space)
           brace_and_space =

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

@@ -40,8 +40,84 @@ module RuboCop
           check_style(node, body)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.class_type?
+              name, superclass, body = *node
+              return if superclass && style != :nested
+            else
+              name, body = *node
+            end
+            nest_or_compact(corrector, node, name, body)
+          end
+        end
+
         private
 
+        def nest_or_compact(corrector, node, name, body)
+          if style == :nested
+            nest_definition(corrector, node)
+          else
+            compact_definition(corrector, node, name, body)
+          end
+        end
+
+        def nest_definition(corrector, node)
+          padding = ((' ' * indent_width) + leading_spaces(node)).to_s
+          padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
+
+          replace_keyword_with_module(corrector, node)
+          split_on_double_colon(corrector, node, padding)
+          add_trailing_end(corrector, node, padding_for_trailing_end)
+        end
+
+        def replace_keyword_with_module(corrector, node)
+          corrector.replace(node.loc.keyword, 'module'.freeze)
+        end
+
+        def split_on_double_colon(corrector, node, padding)
+          children_definition = node.children.first
+          range = range_between(children_definition.loc.double_colon.begin_pos,
+                                children_definition.loc.double_colon.end_pos)
+          replacement = "\n#{padding}#{node.loc.keyword.source} ".freeze
+
+          corrector.replace(range, replacement)
+        end
+
+        def add_trailing_end(corrector, node, padding)
+          replacement = "#{padding}end\n#{leading_spaces(node)}end".freeze
+          corrector.replace(node.loc.end, replacement)
+        end
+
+        def compact_definition(corrector, node, name, body)
+          compact_node(corrector, node, name, body)
+          remove_end(corrector, body)
+        end
+
+        def compact_node(corrector, node, name, body)
+          const_name = "#{name.const_name}::#{body.children.first.const_name}"
+          replacement = "#{body.type} #{const_name}"
+          range = range_between(node.loc.keyword.begin_pos,
+                                body.loc.name.end_pos)
+          corrector.replace(range, replacement)
+        end
+
+        def remove_end(corrector, body)
+          range = range_between(
+            body.loc.end.begin_pos - leading_spaces(body).size,
+            body.loc.end.end_pos + 1
+          )
+          corrector.remove(range)
+        end
+
+        def leading_spaces(node)
+          node.source_range.source_line[/\A\s*/]
+        end
+
+        def indent_width
+          @config.for_cop('IndentationWidth')['Width'] || 2
+        end
+
         def check_style(node, body)
           if style == :nested
             check_nested_style(node)