rubocop 0.51.0 → 0.52.0

data/lib/rubocop/cop/offense.rb

@@ -72,7 +72,7 @@ module RuboCop
       # @return [Boolean]
       #   whether this offense is automatically corrected.
       def corrected
-        @status == :unsupported ? false : @status == :corrected
+        @status == :corrected
       end
       alias corrected? corrected
 
@@ -137,6 +137,11 @@ module RuboCop
         location.last_line
       end
 
+      # @api private
+      def last_column
+        location.last_column
+      end
+
       # @api private
       def column_range
         location.column_range

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

@@ -56,10 +56,6 @@ module RuboCop
         MSG = 'Place `when` conditions with a splat ' \
               'at the end of the `when` branches.'.freeze
         ARRAY_MSG = 'Do not expand array literals in `when` conditions.'.freeze
-        PERCENT_W = '%w'.freeze
-        PERCENT_CAPITAL_W = '%W'.freeze
-        PERCENT_I = '%i'.freeze
-        PERCENT_CAPITAL_I = '%I'.freeze
 
         def on_case(case_node)
           when_conditions = case_node.when_branches.flat_map(&:conditions)
@@ -72,8 +68,6 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(when_node)
           lambda do |corrector|
             if needs_reorder?(when_node)
@@ -84,6 +78,8 @@ module RuboCop
           end
         end
 
+        private
+
         def replacement(conditions)
           reordered = conditions.partition(&:splat_type?).reverse
           reordered.flatten.map(&:source).join(', ')

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

@@ -7,18 +7,18 @@ module RuboCop
       # can better be implemented using `casecmp`.
       #
       # @example
-      #   @bad
+      #   # bad
       #   str.downcase == 'abc'
       #   str.upcase.eql? 'ABC'
       #   'abc' == str.downcase
       #   'ABC'.eql? str.upcase
       #   str.downcase == str.downcase
       #
-      #   @good
+      #   # good
       #   str.casecmp('ABC').zero?
       #   'abc'.casecmp(str).zero?
       class Casecmp < Cop
-        MSG = 'Use `casecmp` instead of `%s %s`.'.freeze
+        MSG = 'Use `casecmp` instead of `%<methods>s`.'.freeze
         CASE_METHODS = %i[downcase upcase].freeze
 
         def_node_matcher :downcase_eq, <<-PATTERN
@@ -40,7 +40,8 @@ module RuboCop
 
           inefficient_comparison(node) do |range, is_other_part, *methods|
             ignore_node(node) if is_other_part
-            add_offense(node, location: range, message: format(MSG, *methods))
+            add_offense(node, location: range,
+                              message: format(MSG, methods: methods.join(' ')))
           end
         end
 

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

@@ -8,13 +8,13 @@ module RuboCop
       # This cop also checks `max` and `min` methods.
       #
       # @example
-      #   @bad
+      #   # bad
       #   array.sort { |a, b| a.foo <=> b.foo }
       #   array.max { |a, b| a.foo <=> b.foo }
       #   array.min { |a, b| a.foo <=> b.foo }
       #   array.sort { |a, b| a[:foo] <=> b[:foo] }
       #
-      #   @good
+      #   # good
       #   array.sort_by(&:foo)
       #   array.sort_by { |v| v.foo }
       #   array.sort_by do |var|
@@ -24,8 +24,9 @@ module RuboCop
       #   array.min_by(&:foo)
       #   array.sort_by { |a| a[:foo] }
       class CompareWithBlock < Cop
-        MSG = 'Use `%s_by%s` instead of ' \
-              '`%s { |%s, %s| %s <=> %s }`.'.freeze
+        MSG = 'Use `%<compare_method>s_by%<instead>s` instead of ' \
+              '`%<compare_method>s { |%<var_a>s, %<var_b>s| %<str_a>s ' \
+              '<=> %<str_b>s }`.'.freeze
 
         def_node_matcher :compare?, <<-PATTERN
           (block
@@ -85,6 +86,7 @@ module RuboCop
           true
         end
 
+        # rubocop:disable Metrics/MethodLength
         def message(send, method, var_a, var_b, args)
           compare_method = send.method_name
           if method == :[]
@@ -97,10 +99,14 @@ module RuboCop
             str_a = "#{var_a}.#{method}"
             str_b = "#{var_b}.#{method}"
           end
-          format(MSG, compare_method, instead,
-                 compare_method, var_a, var_b,
-                 str_a, str_b)
+          format(MSG, compare_method: compare_method,
+                      instead: instead,
+                      var_a: var_a,
+                      var_b: var_b,
+                      str_a: str_a,
+                      str_b: str_b)
         end
+        # rubocop:enable Metrics/MethodLength
 
         def compare_range(send, node)
           range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)

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

@@ -40,7 +40,7 @@ module RuboCop
       class Count < Cop
         include SafeMode
 
-        MSG = 'Use `count` instead of `%s...%s`.'.freeze
+        MSG = 'Use `count` instead of `%<selector>s...%<counter>s`.'.freeze
 
         def_node_matcher :count_candidate?, <<-PATTERN
           {
@@ -61,12 +61,11 @@ module RuboCop
 
             add_offense(node,
                         location: range,
-                        message: format(MSG, selector, counter))
+                        message: format(MSG, selector: selector,
+                                             counter: counter))
           end
         end
 
-        private
-
         def autocorrect(node)
           selector_node, selector, _counter = count_candidate?(node)
           selector_loc = selector_node.loc.selector
@@ -81,6 +80,8 @@ module RuboCop
           end
         end
 
+        private
+
         def eligible_node?(node)
           !(node.parent && node.parent.block_type?)
         end

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

@@ -25,8 +25,10 @@ module RuboCop
       class Detect < Cop
         include SafeMode
 
-        MSG = 'Use `%s` instead of `%s.%s`.'.freeze
-        REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of ' \
+              '`%<first_method>s.%<second_method>s`.'.freeze
+        REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of ' \
+                      '`%<first_method>s.%<second_method>s`.'.freeze
 
         def_node_matcher :detect_candidate?, <<-PATTERN
           {
@@ -84,8 +86,9 @@ module RuboCop
           range = receiver.loc.selector.join(node.loc.selector)
 
           message = second_method == :last ? REVERSE_MSG : MSG
-          formatted_message = format(message, preferred_method, first_method,
-                                     second_method)
+          formatted_message = format(message, prefer: preferred_method,
+                                              first_method: first_method,
+                                              second_method: second_method)
 
           add_offense(node, location: range, message: formatted_message)
         end

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

@@ -8,19 +8,14 @@ module RuboCop
       # with an single `#start_with?`/`#end_with?` call.
       #
       # @example
-      #
-      #   @bad
+      #   # bad
       #   str.start_with?("a") || str.start_with?(Some::CONST)
       #   str.start_with?("a", "b") || str.start_with?("c")
-      #   var1 = ...
-      #   var2 = ...
       #   str.end_with?(var1) || str.end_with?(var2)
       #
-      #   @good
+      #   # good
       #   str.start_with?("a", Some::CONST)
       #   str.start_with?("a", "b", "c")
-      #   var1 = ...
-      #   var2 = ...
       #   str.end_with?(var1, var2)
       class DoubleStartEndWith < Cop
         MSG = 'Use `%<receiver>s.%<method>s(%<combined_args>s)` ' \

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

@@ -7,11 +7,11 @@ module RuboCop
       # would suffice.
       #
       # @example
-      #   @bad
+      #   # bad
       #   'abc' =~ /bc\Z/
       #   'abc'.match(/bc\Z/)
       #
-      #   @good
+      #   # good
       #   'abc'.end_with?('bc')
       class EndWith < Cop
         MSG = 'Use `String#end_with?` instead of a regex match anchored to ' \

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

@@ -15,7 +15,7 @@ module RuboCop
       #   [1, 2, 3, 4].map { |e| [e, e] }.flatten
       #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten
       class FlatMap < Cop
-        MSG = 'Use `flat_map` instead of `%s...%s`.'.freeze
+        MSG = 'Use `flat_map` instead of `%<method>s...%<flatten>s`.'.freeze
         FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
                                   'and `flatten` can be used to flatten ' \
                                   'multiple levels.'.freeze
@@ -67,7 +67,8 @@ module RuboCop
 
           add_offense(node,
                       location: range,
-                      message: format(message, first_method, flatten))
+                      message: format(message, method: first_method,
+                                               flatten: flatten))
         end
       end
     end

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

@@ -7,7 +7,7 @@ module RuboCop
       #
       # Note: If you have an array of two-element arrays, you can put
       #   parentheses around the block arguments to indicate that you're not
-      #   working with a hash, and supress RuboCop offenses.
+      #   working with a hash, and suppress RuboCop offenses.
       #
       # @example
       #   # bad
@@ -22,10 +22,10 @@ module RuboCop
       class HashEachMethods < Cop
         include Lint::UnusedArgument
 
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
 
         def_node_matcher :plain_each, <<-PATTERN
-          (block $(send !(send _ :to_a) :each) (args (arg $_k) (arg $_v)) ...)
+          (block $(send !(send _ :to_a) :each) (args $(arg _k) $(arg _v)) ...)
         PATTERN
 
         def_node_matcher :kv_each, <<-PATTERN
@@ -37,24 +37,39 @@ module RuboCop
           register_kv_offense(node)
         end
 
+        def autocorrect(node)
+          receiver = node.receiver
+          _caller, first_method = *receiver
+
+          lambda do |corrector|
+            case first_method
+            when :keys, :values
+              correct_key_value_each(node, corrector)
+            else
+              correct_plain_each(node, corrector)
+            end
+          end
+        end
+
         private
 
         def register_each_offense(node)
           plain_each(node) do |target, k, v|
-            return if @args[k] && @args[v]
-            used = @args[k] ? :key : :value
+            return if used?(k) && used?(v)
+            used = used?(k) ? :key : :value
 
             add_offense(
               target,
               location: plain_range(target),
-              message: format(message, "each_#{used}", :each)
+              message: format(message, prefer: "each_#{used}", current: :each)
             )
           end
         end
 
         def register_kv_offense(node)
           kv_each(node) do |target, method|
-            msg = format(message, "each_#{method[0..-2]}", "#{method}.each")
+            msg = format(message, prefer: "each_#{method[0..-2]}",
+                                  current: "#{method}.each")
 
             add_offense(target, location: kv_range(target), message: msg)
           end
@@ -62,56 +77,43 @@ module RuboCop
 
         def check_argument(variable)
           return unless variable.block_argument?
-          (@args ||= {})[variable.name] = variable.used?
+          (@block_args ||= []).push(variable)
         end
 
-        def autocorrect(node)
-          receiver, _second_method = *node
-          _caller, first_method = *receiver
-
-          lambda do |corrector|
-            case first_method
-            when :keys, :values
-              return correct_implicit(node, corrector) if receiver.receiver.nil?
-
-              correct_key_value_each(node, corrector)
-            else
-              return correct_implicit(node, corrector) if receiver.nil?
-
-              correct_plain_each(node, corrector)
-            end
-          end
+        def used?(arg)
+          loc = arg.loc
+          variable = @block_args.find { |var| var.declaration_node.loc == loc }
+          variable.used?
         end
 
-        def correct_implicit(node, corrector)
-          method = @args.include?(:k) ? :key : :value
-          new_source = "each_#{method}"
-
-          corrector.replace(node.loc.expression, new_source)
+        def correct_implicit(node, corrector, method_name)
+          corrector.replace(node.loc.expression, method_name)
           correct_args(node, corrector)
         end
 
         def correct_key_value_each(node, corrector)
-          receiver = node.receiver
+          receiver = node.receiver.receiver
+          name = "each_#{node.receiver.method_name.to_s.chop}"
+          return correct_implicit(node, corrector, name) unless receiver
 
-          new_source = receiver.receiver.source +
-                       ".each_#{receiver.method_name[0..-2]}"
+          new_source = receiver.source + ".#{name}"
           corrector.replace(node.loc.expression, new_source)
         end
 
         def correct_plain_each(node, corrector)
-          method = @args.include?(:k) ? :key : :value
-          new_source = node.receiver.source + ".each_#{method}"
+          _each, key, _value = plain_each(node.parent)
+          name = used?(key) ? 'each_key' : 'each_value'
+          return correct_implicit(node, corrector, name) unless node.receiver
 
-          corrector.replace(node.loc.expression, new_source)
+          corrector.replace(node.loc.selector, name)
           correct_args(node, corrector)
         end
 
         def correct_args(node, corrector)
-          args = node.parent.children[1]
-          used_arg = "|#{@args.detect { |_k, v| v }.first}|"
+          args = node.parent.arguments
+          name, = *args.children.find { |arg| used?(arg) }
 
-          corrector.replace(args.source_range, used_arg)
+          corrector.replace(args.source_range, "|#{name}|")
         end
 
         def plain_range(outer_node)
@@ -119,8 +121,7 @@ module RuboCop
         end
 
         def kv_range(outer_node)
-          inner_node = outer_node.children.first
-          inner_node.loc.selector.join(outer_node.loc.selector)
+          outer_node.receiver.loc.selector.join(outer_node.loc.selector)
         end
       end
     end

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

@@ -7,14 +7,14 @@ module RuboCop
       # `strip`.
       #
       # @example
-      #   @bad
+      #   # bad
       #   'abc'.lstrip.rstrip
       #   'abc'.rstrip.lstrip
       #
-      #   @good
+      #   # good
       #   'abc'.strip
       class LstripRstrip < Cop
-        MSG = 'Use `strip` instead of `%s.%s`.'.freeze
+        MSG = 'Use `strip` instead of `%<methods>s`.'.freeze
 
         def_node_matcher :lstrip_rstrip, <<-PATTERN
           {(send $(send _ $:rstrip) $:lstrip)
@@ -27,7 +27,8 @@ module RuboCop
                                   node.source_range.end_pos)
             add_offense(node,
                         location: range,
-                        message: format(MSG, method_one, method_two))
+                        message: format(MSG,
+                                        methods: "#{method_one}.#{method_two}"))
           end
         end
 

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

@@ -7,7 +7,7 @@ module RuboCop
       # where `yield` would do just as well.
       #
       # @example
-      #   @bad
+      #   # bad
       #   def method(&block)
       #     block.call
       #   end
@@ -15,7 +15,7 @@ module RuboCop
       #     func.call 1, 2, 3
       #   end
       #
-      #   @good
+      #   # good
       #   def method
       #     yield
       #   end
@@ -23,7 +23,7 @@ module RuboCop
       #     yield 1, 2, 3
       #   end
       class RedundantBlockCall < Cop
-        MSG = 'Use `yield` instead of `%s.call`.'.freeze
+        MSG = 'Use `yield` instead of `%<argname>s.call`.'.freeze
         YIELD = 'yield'.freeze
         OPEN_PAREN = '('.freeze
         CLOSE_PAREN = ')'.freeze
@@ -47,29 +47,11 @@ module RuboCop
             next unless body
 
             calls_to_report(argname, body).each do |blockcall|
-              add_offense(blockcall, message: format(MSG, argname))
+              add_offense(blockcall, message: format(MSG, argname: argname))
             end
           end
         end
 
-        private
-
-        def calls_to_report(argname, body)
-          return [] if blockarg_assigned?(body, argname)
-
-          calls = to_enum(:blockarg_calls, body, argname)
-
-          return [] if calls.any? { |call| args_include_block_pass?(call) }
-
-          calls
-        end
-
-        def args_include_block_pass?(blockcall)
-          _receiver, _call, *args = *blockcall
-
-          args.any?(&:block_pass_type?)
-        end
-
         # offenses are registered on the `block.call` nodes
         def autocorrect(node)
           _receiver, _method, *args = *node
@@ -87,6 +69,24 @@ module RuboCop
           new_source << CLOSE_PAREN if parentheses?(node) && !args.empty?
           ->(corrector) { corrector.replace(node.source_range, new_source) }
         end
+
+        private
+
+        def calls_to_report(argname, body)
+          return [] if blockarg_assigned?(body, argname)
+
+          calls = to_enum(:blockarg_calls, body, argname)
+
+          return [] if calls.any? { |call| args_include_block_pass?(call) }
+
+          calls
+        end
+
+        def args_include_block_pass?(blockcall)
+          _receiver, _call, *args = *blockcall
+
+          args.any?(&:block_pass_type?)
+        end
       end
     end
   end