rubocop 0.49.1 → 0.52.0

data/lib/rubocop/cop/naming/variable_name.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that all variables use the configured style,
+      # snake_case or camelCase, for their names.
+      #
+      # @example EnforcedStyle: snake_case (default)
+      #   # bad
+      #   fooBar = 1
+      #
+      #   # good
+      #   foo_bar = 1
+      #
+      # @example EnforcedStyle: camelCase
+      #   # bad
+      #   foo_bar = 1
+      #
+      #   # good
+      #   fooBar = 1
+      class VariableName < Cop
+        include ConfigurableNaming
+
+        MSG = 'Use %<style>s for variable names.'.freeze
+
+        def on_lvasgn(node)
+          name, = *node
+          return unless name
+          check_name(node, name, node.loc.name)
+        end
+        alias on_ivasgn    on_lvasgn
+        alias on_cvasgn    on_lvasgn
+        alias on_arg       on_lvasgn
+        alias on_optarg    on_lvasgn
+        alias on_restarg   on_lvasgn
+        alias on_kwoptarg  on_lvasgn
+        alias on_kwarg     on_lvasgn
+        alias on_kwrestarg on_lvasgn
+        alias on_blockarg  on_lvasgn
+
+        private
+
+        def message(style)
+          format(MSG, style: style)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → naming}/variable_number.rb

@@ -2,14 +2,12 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cop makes sure that all numbered variables use the
       # configured style, snake_case, normalcase or non_integer,
       # for their numbering.
       #
-      # @example
-      #   "EnforcedStyle => 'snake_case'"
-      #
+      # @example EnforcedStyle: snake_case
       #   # bad
       #
       #   variable1 = 1
@@ -18,9 +16,7 @@ module RuboCop
       #
       #   variable_1 = 1
       #
-      # @example
-      #   "EnforcedStyle => 'normalcase'"
-      #
+      # @example EnforcedStyle: normalcase (default)
       #   # bad
       #
       #   variable_1 = 1
@@ -29,48 +25,35 @@ module RuboCop
       #
       #   variable1 = 1
       #
-      # @example
-      #   "EnforcedStyle => 'non_integer'"
-      #
-      #   #bad
+      # @example EnforcedStyle: non_integer
+      #   # bad
       #
       #   variable1 = 1
       #
       #   variable_1 = 1
       #
-      #   #good
+      #   # good
       #
       #   variableone = 1
       #
       #   variable_one = 1
-      #
       class VariableNumber < Cop
         include ConfigurableNumbering
 
-        def on_lvasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_ivasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_cvasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
+        MSG = 'Use %<style>s for variable numbers.'.freeze
 
         def on_arg(node)
           name, = *node
           check_name(node, name, node.loc.name)
         end
+        alias on_lvasgn on_arg
+        alias on_ivasgn on_arg
+        alias on_cvasgn on_arg
 
         private
 
         def message(style)
-          format('Use %s for variable numbers.', style)
+          format(MSG, style: style)
         end
       end
     end

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/caller.rb

@@ -8,32 +8,60 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   caller[n]
+      #   caller[1]
       #   caller.first
+      #   caller_locations[1]
+      #   caller_locations.first
       #
       #   # good
-      #   caller(n..n).first
+      #   caller(2..2).first
       #   caller(1..1).first
+      #   caller_locations(2..2).first
+      #   caller_locations(1..1).first
       class Caller < Cop
-        MSG = 'Use `caller(n..n)` instead of `caller[n]`.'.freeze
-        SCOPE_METHODS = %i[first []].freeze
+        MSG_BRACE = 'Use `%<method>s(%<n>d..%<n>d).first`' \
+                    ' instead of `%<method>s[%<m>d]`.'.freeze
+        MSG_FIRST = 'Use `%<method>s(%<n>d..%<n>d).first`' \
+                    ' instead of `%<method>s.first`.'.freeze
+
+        def_node_matcher :slow_caller?, <<-PATTERN
+          {
+            (send nil? {:caller :caller_locations})
+            (send nil? {:caller :caller_locations} int)
+          }
+        PATTERN
 
         def_node_matcher :caller_with_scope_method?, <<-PATTERN
-          (send (send nil :caller ...) ${#{SCOPE_METHODS.map(&:inspect).join(' ')}} ...)
+          {
+            (send #slow_caller? :first)
+            (send #slow_caller? :[] int)
+          }
         PATTERN
 
         def on_send(node)
-          return unless caller_with_scope_method?(node) && slow_caller?(node)
-          add_offense(node, :selector)
+          return unless caller_with_scope_method?(node)
+
+          add_offense(node)
         end
 
         private
 
-        def slow_caller?(node)
-          arguments = node.receiver.arguments
+        def message(node)
+          method_name = node.receiver.method_name
+          caller_arg = node.receiver.first_argument
+          n = caller_arg ? int_value(caller_arg) : 1
+
+          if node.method_name == :[]
+            m = int_value(node.first_argument)
+            n += m
+            format(MSG_BRACE, n: n, m: m, method: method_name)
+          else
+            format(MSG_FIRST, n: n, method: method_name)
+          end
+        end
 
-          arguments.empty? ||
-            (arguments.length == 1 && arguments[0].int_type?)
+        def int_value(node)
+          node.children[0]
         end
       end
     end

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)
@@ -68,12 +64,10 @@ module RuboCop
             range = condition.parent.loc.keyword.join(condition.source_range)
             variable, = *condition
             message = variable.array_type? ? ARRAY_MSG : MSG
-            add_offense(condition.parent, range, message)
+            add_offense(condition.parent, location: range, message: message)
           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,40 +7,41 @@ 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, <<-END
+        def_node_matcher :downcase_eq, <<-PATTERN
           (send
             $(send _ ${:downcase :upcase})
             ${:== :eql? :!=}
             ${str (send _ {:downcase :upcase} ...) (begin str)})
-        END
+        PATTERN
 
-        def_node_matcher :eq_downcase, <<-END
+        def_node_matcher :eq_downcase, <<-PATTERN
           (send
             {str (send _ {:downcase :upcase} ...) (begin str)}
             ${:== :eql? :!=}
             $(send _ ${:downcase :upcase}))
-        END
+        PATTERN
 
         def on_send(node)
           return if part_of_ignored_node?(node)
 
           inefficient_comparison(node) do |range, is_other_part, *methods|
             ignore_node(node) if is_other_part
-            add_offense(node, range, 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,30 +24,35 @@ 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?, <<-END
+        def_node_matcher :compare?, <<-PATTERN
           (block
             $(send _ {:sort :min :max})
             (args (arg $_a) (arg $_b))
             $send)
-        END
+        PATTERN
 
-        def_node_matcher :replaceable_body?, <<-END
+        def_node_matcher :replaceable_body?, <<-PATTERN
           (send
             (send (lvar %1) $_method $...)
             :<=>
             (send (lvar %2) _method $...))
-        END
+        PATTERN
 
         def on_block(node)
           compare?(node) do |send, var_a, var_b, body|
             replaceable_body?(body, var_a, var_b) do |method, args_a, args_b|
               return unless slow_compare?(method, args_a, args_b)
               range = compare_range(send, node)
-              add_offense(node, range,
-                          message(send, method, var_a, var_b, args_a))
+
+              add_offense(
+                node,
+                location: range,
+                message: message(send, method, var_a, var_b, args_a)
+              )
             end
           end
         end
@@ -81,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 == :[]
@@ -93,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
           {
@@ -59,12 +59,13 @@ module RuboCop
               selector_node.loc.selector.begin_pos
             end
 
-            add_offense(node, range, format(MSG, selector, counter))
+            add_offense(node,
+                        location: range,
+                        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
@@ -79,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,10 +86,11 @@ module RuboCop
           range = receiver.loc.selector.join(node.loc.selector)
 
           message = second_method == :last ? REVERSE_MSG : MSG
-          add_offense(node, range, 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
 
         def preferred_method