rubocop 0.47.1 → 0.48.0

data/lib/rubocop/cop/mixin/on_method_def.rb

@@ -34,10 +34,10 @@ module RuboCop
       # private def my_method
       # which are allowed in Ruby 2.1 and later.
       def modifier_and_def_on_same_line?(send_node)
-        send_node.receiver.nil? &&
+        !send_node.receiver &&
           send_node.method_name != :def &&
-          send_node.method_args.size == 1 &&
-          [:def, :defs].include?(send_node.method_args.first.type)
+          send_node.arguments.one? &&
+          %i(def defs).include?(send_node.first_argument.type)
       end
     end
   end

data/lib/rubocop/cop/mixin/percent_literal.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for handling percent literals.
     module PercentLiteral
+      private
+
       def percent_literal?(node)
         return unless (begin_source = begin_source(node))
         begin_source.start_with?('%')
@@ -27,6 +29,31 @@ module RuboCop
       def contents_range(node)
         range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
       end
+
+      # ['a', 'b', 'c'] => %w(a b c)
+      def correct_percent(node, char)
+        words = node.children
+        escape = words.any? { |w| needs_escaping?(w.children[0]) }
+        char = char.upcase if escape
+        contents = autocorrect_words(words, escape, node.loc.line)
+
+        lambda do |corrector|
+          corrector.replace(node.source_range, "%#{char}(#{contents})")
+        end
+      end
+
+      def autocorrect_words(word_nodes, escape, base_line_number)
+        previous_node_line_number = base_line_number
+        word_nodes.map do |node|
+          number_of_line_breaks = node.loc.line - previous_node_line_number
+          line_breaks = "\n" * number_of_line_breaks
+          previous_node_line_number = node.loc.line
+          content = node.children.first.to_s
+          content = escape ? escape_string(content) : content
+          content.gsub!(/\)/, '\\)')
+          line_breaks + content
+        end.join(' ')
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/rescue_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking `rescue` nodes.
+    module RescueNode
+      def investigate(processed_source)
+        @modifier_locations = processed_source
+                              .tokens
+                              .select { |t| t.type == :kRESCUE_MOD }
+                              .map(&:pos)
+      end
+
+      def rescue_modifier?(node)
+        node &&
+          node.resbody_type? &&
+          @modifier_locations.include?(node.loc.keyword)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/safe_mode.rb

@@ -15,7 +15,7 @@ module RuboCop
       end
 
       def rails?
-        config['Rails'] && config['Rails']['Enabled']
+        config['Rails'] && config['Rails'].fetch('Enabled')
       end
     end
   end

data/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -33,7 +33,7 @@ module RuboCop
       end
 
       def allowed_type?(token)
-        [:tRPAREN, :tRBRACK, :tPIPE].include?(token.type)
+        %i(tRPAREN tRBRACK tPIPE).include?(token.type)
       end
 
       def space_forbidden_before_rcurly?

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -13,7 +13,8 @@ module RuboCop
       end
 
       def non_eligible_node?(node)
-        line_count(node) > 3 || commented?(node.loc.end)
+        line_count(node) > 3 ||
+          !node.modifier_form? && commented?(node.loc.end)
       end
 
       def non_eligible_body?(body)

data/lib/rubocop/cop/mixin/target_rails_version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking target rails version.
+    module TargetRailsVersion
+      def minimum_target_rails_version(version)
+        @minimum_target_rails_version = version
+      end
+
+      def support_target_rails_version?(version)
+        @minimum_target_rails_version <= version
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/unused_argument.rb

@@ -24,7 +24,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          return if [:kwarg, :kwoptarg].include?(node.type)
+          return if %i(kwarg kwoptarg).include?(node.type)
 
           if node.blockarg_type?
             lambda do |corrector|

data/lib/rubocop/cop/offense.rb

@@ -7,8 +7,8 @@ module RuboCop
       include Comparable
 
       # @api private
-      COMPARISON_ATTRIBUTES = [:line, :column, :cop_name,
-                               :message, :severity].freeze
+      COMPARISON_ATTRIBUTES = %i(line column cop_name
+                                 message severity).freeze
 
       # @api public
       #
@@ -72,7 +72,7 @@ module RuboCop
       # @return [Boolean]
       #   whether this offense is automatically corrected.
       def corrected
-        @status == :unsupported ? nil : @status == :corrected
+        @status == :unsupported ? false : @status == :corrected
       end
       alias corrected? corrected
 

data/lib/rubocop/cop/performance/casecmp.rb

@@ -19,7 +19,7 @@ module RuboCop
       #   'abc'.casecmp(str).zero?
       class Casecmp < Cop
         MSG = 'Use `casecmp` instead of `%s %s`.'.freeze
-        CASE_METHODS = [:downcase, :upcase].freeze
+        CASE_METHODS = %i(downcase upcase).freeze
 
         def_node_matcher :downcase_eq, <<-END
           (send

data/lib/rubocop/cop/performance/detect.rb

@@ -96,7 +96,8 @@ module RuboCop
         end
 
         def lazy?(node)
-          return false if node.nil?
+          return false unless node
+
           receiver, method, _args = *node
           method == :lazy && !receiver.nil?
         end

data/lib/rubocop/cop/performance/double_start_end_with.rb

@@ -30,7 +30,7 @@ module RuboCop
           receiver,
           method,
           first_call_args,
-          second_call_args = two_start_end_with_calls(node)
+          second_call_args = process_source(node)
 
           return unless receiver && second_call_args.all?(&:pure?)
 
@@ -39,8 +39,30 @@ module RuboCop
           add_offense_for_double_call(node, receiver, method, combined_args)
         end
 
+        def autocorrect(node)
+          _receiver, _method,
+          first_call_args, second_call_args = process_source(node)
+
+          combined_args = combine_args(first_call_args, second_call_args)
+          first_argument = first_call_args.first.loc.expression
+          last_argument = second_call_args.last.loc.expression
+          range = first_argument.join(last_argument)
+
+          lambda do |corrector|
+            corrector.replace(range, combined_args)
+          end
+        end
+
         private
 
+        def process_source(node)
+          if check_for_active_support_aliases?
+            check_with_active_support_aliases(node)
+          else
+            two_start_end_with_calls(node)
+          end
+        end
+
         def combine_args(first_call_args, second_call_args)
           (first_call_args + second_call_args).map(&:source).join(', ')
         end
@@ -57,11 +79,23 @@ module RuboCop
                       ))
         end
 
+        def check_for_active_support_aliases?
+          cop_config['IncludeActiveSupportAliases']
+        end
+
         def_node_matcher :two_start_end_with_calls, <<-END
           (or
             (send $_recv [{:start_with? :end_with?} $_method] $...)
             (send _recv _method $...))
         END
+
+        def_node_matcher :check_with_active_support_aliases, <<-END
+          (or
+            (send $_recv
+                    [{:start_with? :starts_with? :end_with? :ends_with?} $_method]
+                  $...)
+            (send _recv _method $...))
+        END
       end
     end
   end

data/lib/rubocop/cop/performance/end_with.rb

@@ -32,7 +32,9 @@ module RuboCop
         end
 
         def on_send(node)
-          add_offense(node, :expression, MSG) if redundant_regex?(node)
+          return unless redundant_regex?(node)
+
+          add_offense(node, :expression)
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/performance/flat_map.rb

@@ -27,8 +27,7 @@ module RuboCop
         def on_send(node)
           flat_map_candidate?(node) do |map_node, first_method, flatten, params|
             flatten_level, = *params.first
-            if cop_config['EnabledForFlattenWithoutParams'] &&
-               flatten_level.nil?
+            if cop_config['EnabledForFlattenWithoutParams'] && !flatten_level
               offense_for_levels(node, map_node, first_method, flatten)
             elsif flatten_level == 1
               offense_for_method(node, map_node, first_method, flatten)
@@ -39,12 +38,13 @@ module RuboCop
         def autocorrect(node)
           map_node, _first_method, _flatten, params = flat_map_candidate?(node)
           flatten_level, = *params.first
-          return if flatten_level.nil?
 
-          lambda do |corrector|
-            range = range_between(node.loc.dot.begin_pos,
-                                  node.source_range.end_pos)
+          return unless flatten_level
+
+          range = range_between(node.loc.dot.begin_pos,
+                                node.source_range.end_pos)
 
+          lambda do |corrector|
             corrector.remove(range)
             corrector.replace(map_node.loc.selector, 'flat_map')
           end

data/lib/rubocop/cop/performance/lstrip_rstrip.rb

@@ -30,9 +30,9 @@ module RuboCop
         end
 
         def autocorrect(node)
-          first_send, = *node
-          range = range_between(first_send.loc.selector.begin_pos,
+          range = range_between(node.receiver.loc.selector.begin_pos,
                                 node.source_range.end_pos)
+
           ->(corrector) { corrector.replace(range, 'strip') }
         end
       end

data/lib/rubocop/cop/performance/range_include.rb

@@ -27,7 +27,9 @@ module RuboCop
         END
 
         def on_send(node)
-          add_offense(node, :selector, MSG) if range_include(node)
+          return unless range_include(node)
+
+          add_offense(node, :selector)
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/performance/redundant_match.rb

@@ -35,17 +35,18 @@ module RuboCop
           return unless match_call?(node) &&
                         (!node.value_used? || only_truthiness_matters?(node)) &&
                         !(node.parent && node.parent.block_type?)
-          add_offense(node, :expression, MSG)
+
+          add_offense(node, :expression)
         end
 
         def autocorrect(node)
-          receiver, _method, arg = *node
-
           # Regexp#match can take a second argument, but this cop doesn't
           # register an offense in that case
-          return unless arg.regexp_type?
+          return unless node.first_argument.regexp_type?
+
+          new_source =
+            node.receiver.source + ' =~ ' + node.first_argument.source
 
-          new_source = receiver.source + ' =~ ' + arg.source
           ->(corrector) { corrector.replace(node.source_range, new_source) }
         end
       end

data/lib/rubocop/cop/performance/regexp_match.rb

@@ -102,7 +102,7 @@ module RuboCop
             (send (const nil :Regexp) :last_match)
             (send (const nil :Regexp) :last_match _)
             ({back_ref nth_ref} _)
-            (gvar #dollar_tilde)
+            (gvar #match_gvar?)
           }
         PATTERN
 
@@ -190,8 +190,15 @@ module RuboCop
           end
         end
 
-        def dollar_tilde(sym)
-          sym == :$~
+        def match_gvar?(sym)
+          %i(
+            $~
+            $MATCH
+            $PREMATCH
+            $POSTMATCH
+            $LAST_PAREN_MATCH
+            $LAST_MATCH_INFO
+          ).include?(sym)
         end
 
         def correct_operator(corrector, recv, arg)

data/lib/rubocop/cop/performance/reverse_each.rb

@@ -26,7 +26,8 @@ module RuboCop
             end_location = node.loc.selector.end_pos
 
             range = range_between(location_of_reverse, end_location)
-            add_offense(node, range, MSG)
+
+            add_offense(node, range)
           end
         end
 

data/lib/rubocop/cop/performance/size.rb

@@ -39,12 +39,9 @@ module RuboCop
         end
 
         def eligible_node?(node)
-          receiver, method, args = *node
+          return false unless node.method?(:count) && !node.arguments?
 
-          return false unless method == :count
-          return false if args
-
-          eligible_receiver?(receiver) && !allowed_parent?(node.parent)
+          eligible_receiver?(node.receiver) && !allowed_parent?(node.parent)
         end
 
         def eligible_receiver?(node)
@@ -58,17 +55,15 @@ module RuboCop
         end
 
         def array?(node)
-          receiver, method = *node
-          _, constant = *receiver
+          _, constant = *node.receiver
 
-          node.array_type? || constant == :Array || method == :to_a
+          node.array_type? || constant == :Array || node.method_name == :to_a
         end
 
         def hash?(node)
-          receiver, method = *node
-          _, constant = *receiver
+          _, constant = *node.receiver
 
-          node.hash_type? || constant == :Hash || method == :to_h
+          node.hash_type? || constant == :Hash || node.method_name == :to_h
         end
       end
     end

data/lib/rubocop/cop/performance/start_with.rb

@@ -35,7 +35,9 @@ module RuboCop
         end
 
         def on_send(node)
-          add_offense(node, :expression, MSG) if redundant_regex?(node)
+          return unless redundant_regex?(node)
+
+          add_offense(node, :expression)
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/performance/string_replacement.rb

@@ -27,22 +27,22 @@ module RuboCop
         SINGLE_QUOTE = "'".freeze
 
         def_node_matcher :string_replacement?, <<-PATTERN
-          (send _ ${:gsub :gsub!}
+          (send _ {:gsub :gsub!}
                     ${regexp str (send (const nil :Regexp) {:new :compile} _)}
                     $str)
         PATTERN
 
         def on_send(node)
-          string_replacement?(node) do |method, first_param, second_param|
+          string_replacement?(node) do |first_param, second_param|
             return if accept_second_param?(second_param)
             return if accept_first_param?(first_param)
 
-            offense(node, method, first_param, second_param)
+            offense(node, first_param, second_param)
           end
         end
 
         def autocorrect(node)
-          _string, method, first_param, second_param = *node
+          _string, _method, first_param, second_param = *node
           first_source, = first_source(first_param)
           second_source, = *second_param
 
@@ -51,7 +51,7 @@ module RuboCop
           end
 
           replacement_method =
-            replacement_method(method, first_source, second_source)
+            replacement_method(node, first_source, second_source)
 
           replace_method(node, first_source, second_source, first_param,
                          replacement_method)
@@ -93,13 +93,13 @@ module RuboCop
           first_source.length != 1
         end
 
-        def offense(node, method, first_param, second_param)
+        def offense(node, first_param, second_param)
           first_source, = first_source(first_param)
           unless first_param.str_type?
             first_source = interpret_string_escapes(first_source)
           end
           second_source, = *second_param
-          message = message(method, first_source, second_source)
+          message = message(node, first_source, second_source)
 
           add_offense(node, range(node), message)
         end
@@ -137,26 +137,21 @@ module RuboCop
           range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
-        def replacement_method(method, first_source, second_source)
+        def replacement_method(node, first_source, second_source)
           replacement = if second_source.empty? && first_source.length == 1
                           DELETE
                         else
                           TR
                         end
 
-          "#{replacement}#{BANG if bang_method?(method)}"
+          "#{replacement}#{BANG if node.bang_method?}"
         end
 
-        def message(method, first_source, second_source)
-          replacement_method = replacement_method(method,
-                                                  first_source,
-                                                  second_source)
-
-          format(MSG, replacement_method, method)
-        end
+        def message(node, first_source, second_source)
+          replacement_method =
+            replacement_method(node, first_source, second_source)
 
-        def bang_method?(method)
-          method.to_s.end_with?(BANG)
+          format(MSG, replacement_method, node.method_name)
         end
 
         def method_suffix(node)