rubocop 0.49.1 → 0.50.0

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks that your heredocs are using meaningful delimiters.
+      # By default it disallows `END` and `EO*`, and can be configured through
+      # blacklisting additional delimiters.
+      #
+      # @example
+      #
+      #   # good
+      #   <<-SQL
+      #     SELECT * FROM foo
+      #   SQL
+      #
+      #   # bad
+      #   <<-END
+      #     SELECT * FROM foo
+      #   END
+      #
+      #   # bad
+      #   <<-EOS
+      #     SELECT * FROM foo
+      #   EOS
+      class HeredocDelimiterNaming < Cop
+        include Heredoc
+
+        MSG = 'Use meaningful heredoc delimiters.'.freeze
+        OPENING_DELIMITER = /<<[~-]?'?(\w+)'?\b/
+
+        def on_heredoc(node)
+          return if meaningful_delimiters?(node)
+
+          add_offense(node, :heredoc_end)
+        end
+
+        private
+
+        def meaningful_delimiters?(node)
+          delimiters = delimiters(node)
+
+          blacklisted_delimiters.none? do |blacklisted_delimiter|
+            delimiters =~ Regexp.new(blacklisted_delimiter)
+          end
+        end
+
+        def delimiters(node)
+          node.source.match(OPENING_DELIMITER).captures.first
+        end
+
+        def blacklisted_delimiters
+          cop_config['Blacklist'] || []
+        end
+      end
+    end
+  end
+end

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

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cop makes sure that all methods use the configured style,
       # snake_case or camelCase, for their names. Some special arrangements
       # have to be made for operator methods.

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

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cop makes sure that predicates are named properly.
       #
       # @example
@@ -18,13 +18,9 @@ module RuboCop
       #   # good
       #   def value? ...
       class PredicateName < Cop
-        include OnMethodDef
-
-        private
-
-        def on_method_def(node, method_name, _args, _body)
+        def on_def(node)
           predicate_prefixes.each do |prefix|
-            method_name = method_name.to_s
+            method_name = node.method_name.to_s
             next unless method_name.start_with?(prefix)
             next if method_name == expected_name(method_name, prefix)
             next if predicate_whitelist.include?(method_name)
@@ -35,6 +31,9 @@ module RuboCop
             )
           end
         end
+        alias on_defs on_def
+
+        private
 
         def expected_name(method_name, prefix)
           new_name = if prefix_blacklist.include?(prefix)

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

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cop makes sure that all variables use the configured style,
       # snake_case or camelCase, for their names.
       class VariableName < Cop
@@ -10,23 +10,19 @@ module RuboCop
 
         def on_lvasgn(node)
           name, = *node
+          return unless name
           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
-
-        def on_arg(node)
-          name, = *node
-          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
 

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

@@ -2,7 +2,7 @@
 
 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.

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

@@ -21,19 +21,19 @@ module RuboCop
         MSG = 'Use `casecmp` instead of `%s %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)

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

@@ -27,19 +27,19 @@ module RuboCop
         MSG = 'Use `%s_by%s` instead of ' \
               '`%s { |%s, %s| %s <=> %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|

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

@@ -83,19 +83,19 @@ module RuboCop
           cop_config['IncludeActiveSupportAliases']
         end
 
-        def_node_matcher :two_start_end_with_calls, <<-END
+        def_node_matcher :two_start_end_with_calls, <<-PATTERN
           (or
             (send $_recv [{:start_with? :end_with?} $_method] $...)
             (send _recv _method $...))
-        END
+        PATTERN
 
-        def_node_matcher :check_with_active_support_aliases, <<-END
+        def_node_matcher :check_with_active_support_aliases, <<-PATTERN
           (or
             (send $_recv
                     [{:start_with? :starts_with? :end_with? :ends_with?} $_method]
                   $...)
             (send _recv _method $...))
-        END
+        PATTERN
       end
     end
   end

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

@@ -18,10 +18,10 @@ module RuboCop
               'the end of the string.'.freeze
         SINGLE_QUOTE = "'".freeze
 
-        def_node_matcher :redundant_regex?, <<-END
+        def_node_matcher :redundant_regex?, <<-PATTERN
           {(send $!nil {:match :=~} (regexp (str $#literal_at_end?) (regopt)))
            (send (regexp (str $#literal_at_end?) (regopt)) {:match :=~} $_)}
-        END
+        PATTERN
 
         def literal_at_end?(regex_str)
           # is this regexp 'literal' in the sense of only matching literal
@@ -33,7 +33,7 @@ module RuboCop
         def on_send(node)
           return unless redundant_regex?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

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

@@ -17,7 +17,7 @@ module RuboCop
           counter(node) do |var, arg|
             return if allowed_variable?(var) || allowed_argument?(arg)
 
-            add_offense(node, :expression)
+            add_offense(node)
           end
         end
 

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

@@ -20,26 +20,40 @@ module RuboCop
 
         MSG = 'Use `%s` instead of `%s`.'.freeze
 
-        def_node_matcher :plain_each, <<-END
-          (block $(send (send _ :hash) :each) (args (arg $_k) (arg $_v)) ...)
-        END
+        def_node_matcher :plain_each, <<-PATTERN
+          (block $(send _ :each) (args (arg $_k) (arg $_v)) ...)
+        PATTERN
 
-        def_node_matcher :kv_each, <<-END
-          (block $(send (send (send _ :hash) ${:keys :values}) :each) ...)
-        END
+        def_node_matcher :kv_each, <<-PATTERN
+          (block $(send (send _ ${:keys :values}) :each) ...)
+        PATTERN
 
         def on_block(node)
+          register_each_offense(node)
+          register_kv_offense(node)
+        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
-            add_offense(target, range(target), format(message,
-                                                      "each_#{used}",
-                                                      :each))
+            add_offense(
+              target, plain_range(target), format(message,
+                                                  "each_#{used}",
+                                                  :each)
+            )
           end
+        end
+
+        def register_kv_offense(node)
           kv_each(node) do |target, method|
-            add_offense(target, range(target), format(message,
-                                                      "each_#{method[0..-2]}",
-                                                      "#{method}.each"))
+            add_offense(
+              target, kv_range(target), format(message,
+                                               "each_#{method[0..-2]}",
+                                               "#{method}.each")
+            )
           end
         end
 
@@ -50,31 +64,58 @@ module RuboCop
 
         def autocorrect(node)
           receiver, _second_method = *node
-          caller, first_method = *receiver
+          _caller, first_method = *receiver
+
           lambda do |corrector|
-            if first_method == :hash
-              method = @args.values.first ? :key : :value
-              new_source = receiver.source + ".each_#{method}"
-              corrector.replace(node.loc.expression, new_source)
-              correct_args(node, corrector)
+            case first_method
+            when :keys, :values
+              return correct_implicit(node, corrector) if receiver.receiver.nil?
+
+              correct_key_value_each(node, corrector)
             else
-              new_source = caller.source + ".each_#{first_method[0..-2]}"
-              corrector.replace(node.loc.expression, new_source)
+              return correct_implicit(node, corrector) if receiver.nil?
+
+              correct_plain_each(node, corrector)
             end
           end
         end
 
-        private
+        def correct_implicit(node, corrector)
+          method = @args.include?(:k) ? :key : :value
+          new_source = "each_#{method}"
+
+          corrector.replace(node.loc.expression, new_source)
+          correct_args(node, corrector)
+        end
+
+        def correct_key_value_each(node, corrector)
+          receiver = node.receiver
+
+          new_source = receiver.receiver.source +
+                       ".each_#{receiver.method_name[0..-2]}"
+          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}"
+
+          corrector.replace(node.loc.expression, new_source)
+          correct_args(node, corrector)
+        end
 
         def correct_args(node, corrector)
           args = node.parent.children[1]
           used_arg = "|#{@args.detect { |_k, v| v }.first}|"
-          args_range = range_between(args.loc.begin.begin_pos,
-                                     args.loc.end.end_pos)
-          corrector.replace(args_range, used_arg)
+
+          corrector.replace(args.source_range, used_arg)
+        end
+
+        def plain_range(outer_node)
+          outer_node.loc.selector
         end
 
-        def range(outer_node)
+        def kv_range(outer_node)
           inner_node = outer_node.children.first
           inner_node.loc.selector.join(outer_node.loc.selector)
         end