rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,56 +8,86 @@ 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}.%{method}(%{combined_args})` ' \
-              'instead of `%{original_code}`.'.freeze
+        MSG = 'Use `%<receiver>s.%<method>s(%<combined_args>s)` ' \
+              'instead of `%<original_code>s`.'.freeze
 
         def on_or(node)
           receiver,
           method,
           first_call_args,
-          second_call_args = two_start_end_with_calls(node)
-
-          if receiver && second_call_args.all?(&:pure?)
-            add_offense(
-              node,
-              :expression,
-              format(
-                MSG,
-                receiver: receiver.source,
-                method: method,
-                combined_args: combine_args(first_call_args, second_call_args),
-                original_code: node.source
-              )
-            )
+          second_call_args = process_source(node)
+
+          return unless receiver && second_call_args.all?(&:pure?)
+
+          combined_args = combine_args(first_call_args, second_call_args)
+
+          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
 
-        def_node_matcher :two_start_end_with_calls, <<-END
+        def add_offense_for_double_call(node, receiver, method, combined_args)
+          msg = format(MSG, receiver: receiver.source,
+                            method: method,
+                            combined_args: combined_args,
+                            original_code: node.source)
+
+          add_offense(node, message: msg)
+        end
+
+        def check_for_active_support_aliases?
+          cop_config['IncludeActiveSupportAliases']
+        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, <<-PATTERN
+          (or
+            (send $_recv
+                    [{:start_with? :starts_with? :end_with? :ends_with?} $_method]
+                  $...)
+            (send _recv _method $...))
+        PATTERN
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,22 +7,21 @@ module RuboCop
       # would suffice.
       #
       # @example
-      #   @bad
+      #   # bad
       #   'abc' =~ /bc\Z/
       #   'abc'.match(/bc\Z/)
       #
-      #   @good
-      #   'abc' =~ /ab/
-      #   'abc' =~ /\w*\Z/
+      #   # good
+      #   'abc'.end_with?('bc')
       class EndWith < Cop
         MSG = 'Use `String#end_with?` instead of a regex match anchored to ' \
               'the end of the string.'.freeze
         SINGLE_QUOTE = "'".freeze
 
-        def_node_matcher :redundant_regex?, <<-END
-          {(send $!nil {:match :=~} (regexp (str $#literal_at_end?) (regopt)))
+        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 +31,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)
         end
 
         def autocorrect(node)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -13,37 +12,42 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          counter(node) do |variable, arg|
-            return if contains_splat?(variable)
-            return if contains_double_splat?(variable)
-            return if !arg.nil? && string_argument?(arg.first)
-            if node.parent
-              return if node.parent.casgn_type? || node.parent.block_type?
-            end
-
-            add_offense(node, :expression)
+          return if allowed_parent?(node.parent)
+
+          counter(node) do |var, arg|
+            return if allowed_variable?(var) || allowed_argument?(arg)
+
+            add_offense(node)
           end
         end
 
         private
 
+        def allowed_variable?(var)
+          contains_splat?(var) || contains_double_splat?(var)
+        end
+
+        def allowed_argument?(arg)
+          arg && non_string_argument?(arg.first)
+        end
+
+        def allowed_parent?(node)
+          node && (node.casgn_type? || node.block_type?)
+        end
+
         def contains_splat?(node)
           return unless node.array_type?
 
-          node.children.any? do |child|
-            child.respond_to?(:splat_type?) && child.splat_type?
-          end
+          node.each_child_node(:splat).any?
         end
 
         def contains_double_splat?(node)
           return unless node.hash_type?
 
-          node.children.any? do |child|
-            child.respond_to?(:kwsplat_type?) && child.kwsplat_type?
-          end
+          node.each_child_node(:kwsplat).any?
         end
 
-        def string_argument?(node)
+        def non_string_argument?(node)
           node && !node.str_type?
         end
       end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -16,62 +15,60 @@ 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
-        FLATTEN = [:flatten, :flatten!].freeze
 
-        def on_send(node)
-          left, second_method, flatten_param = *node
-          return unless FLATTEN.include?(second_method)
-
-          flatten_level, = *flatten_param
-          expression, = *left
-          _array, first_method = *expression
-          return unless first_method == :map || first_method == :collect
+        def_node_matcher :flat_map_candidate?, <<-PATTERN
+          (send (block $(send _ ${:collect :map}) ...) ${:flatten :flatten!} $...)
+        PATTERN
 
-          if cop_config['EnabledForFlattenWithoutParams'] && flatten_level.nil?
-            offense_for_levels(node, expression, first_method, second_method)
-          elsif flatten_level == 1
-            offense_for_method(node, expression, first_method, second_method)
+        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
+              offense_for_levels(node, map_node, first_method, flatten)
+            elsif flatten_level == 1
+              offense_for_method(node, map_node, first_method, flatten)
+            end
           end
         end
 
         def autocorrect(node)
-          receiver, _flatten, flatten_param = *node
-          flatten_level, = *flatten_param
-          return if flatten_level.nil?
+          map_node, _first_method, _flatten, params = flat_map_candidate?(node)
+          flatten_level, = *params.first
 
-          array, = *receiver
+          return unless flatten_level
 
-          lambda do |corrector|
-            range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                              node.loc.dot.begin_pos,
-                                              node.source_range.end_pos)
+          range = range_between(node.loc.dot.begin_pos,
+                                node.source_range.end_pos)
 
+          lambda do |corrector|
             corrector.remove(range)
-            corrector.replace(array.loc.selector, 'flat_map')
+            corrector.replace(map_node.loc.selector, 'flat_map')
           end
         end
 
         private
 
-        def offense_for_levels(node, expression, first_method, second_method)
+        def offense_for_levels(node, map_node, first_method, flatten)
           message = MSG + FLATTEN_MULTIPLE_LEVELS
-          offense(node, expression, first_method, second_method, message)
+          register_offense(node, map_node, first_method, flatten, message)
         end
 
-        def offense_for_method(node, expression, first_method, second_method)
-          offense(node, expression, first_method, second_method, MSG)
+        def offense_for_method(node, map_node, first_method, flatten)
+          register_offense(node, map_node, first_method, flatten, MSG)
         end
 
-        def offense(node, expression, first_method, second_method, message)
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            expression.loc.selector.begin_pos,
-                                            node.loc.selector.end_pos)
+        def register_offense(node, map_node, first_method, flatten, message)
+          range = range_between(map_node.loc.selector.begin_pos,
+                                node.loc.expression.end_pos)
 
-          add_offense(node, range, format(message, first_method, second_method))
+          add_offense(node,
+                      location: range,
+                      message: format(message, method: first_method,
+                                               flatten: flatten))
         end
       end
     end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop checks for uses of `each_key` and `each_value` Hash methods.
+      #
+      # 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 suppress RuboCop offenses.
+      #
+      # @example
+      #   # bad
+      #   hash.keys.each { |k| p k }
+      #   hash.values.each { |v| p v }
+      #   hash.each { |k, _v| p k }
+      #   hash.each { |_k, v| p v }
+      #
+      #   # good
+      #   hash.each_key { |k| p k }
+      #   hash.each_value { |v| p v }
+      class HashEachMethods < Cop
+        include Lint::UnusedArgument
+
+        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)) ...)
+        PATTERN
+
+        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
+
+        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 used?(k) && used?(v)
+            used = used?(k) ? :key : :value
+
+            add_offense(
+              target,
+              location: plain_range(target),
+              message: format(message, prefer: "each_#{used}", current: :each)
+            )
+          end
+        end
+
+        def register_kv_offense(node)
+          kv_each(node) do |target, method|
+            msg = format(message, prefer: "each_#{method[0..-2]}",
+                                  current: "#{method}.each")
+
+            add_offense(target, location: kv_range(target), message: msg)
+          end
+        end
+
+        def check_argument(variable)
+          return unless variable.block_argument?
+          (@block_args ||= []).push(variable)
+        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_name)
+          corrector.replace(node.loc.expression, method_name)
+          correct_args(node, corrector)
+        end
+
+        def correct_key_value_each(node, corrector)
+          receiver = node.receiver.receiver
+          name = "each_#{node.receiver.method_name.to_s.chop}"
+          return correct_implicit(node, corrector, name) unless receiver
+
+          new_source = receiver.source + ".#{name}"
+          corrector.replace(node.loc.expression, new_source)
+        end
+
+        def correct_plain_each(node, corrector)
+          _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.selector, name)
+          correct_args(node, corrector)
+        end
+
+        def correct_args(node, corrector)
+          args = node.parent.arguments
+          name, = *args.children.find { |arg| used?(arg) }
+
+          corrector.replace(args.source_range, "|#{name}|")
+        end
+
+        def plain_range(outer_node)
+          outer_node.loc.selector
+        end
+
+        def kv_range(outer_node)
+          outer_node.receiver.loc.selector.join(outer_node.loc.selector)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,34 +7,35 @@ 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, <<-END
+        def_node_matcher :lstrip_rstrip, <<-PATTERN
           {(send $(send _ $:rstrip) $:lstrip)
            (send $(send _ $:lstrip) $:rstrip)}
-        END
+        PATTERN
 
         def on_send(node)
           lstrip_rstrip(node) do |first_send, method_one, method_two|
-            range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                              first_send.loc.selector.begin_pos,
-                                              node.source_range.end_pos)
-            add_offense(node, range, format(MSG, method_one, method_two))
+            range = range_between(first_send.loc.selector.begin_pos,
+                                  node.source_range.end_pos)
+            add_offense(node,
+                        location: range,
+                        message: format(MSG,
+                                        methods: "#{method_one}.#{method_two}"))
           end
         end
 
         def autocorrect(node)
-          first_send, = *node
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            first_send.loc.selector.begin_pos,
-                                            node.source_range.end_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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -23,12 +22,14 @@ module RuboCop
         # Right now, we only detect direct calls on a Range literal
         # (We don't even catch it if the Range is in double parens)
 
-        def_node_matcher :range_include, <<-END
+        def_node_matcher :range_include, <<-PATTERN
           (send {irange erange (begin {irange erange})} :include? ...)
-        END
+        PATTERN
 
         def on_send(node)
-          add_offense(node, :selector, MSG) if range_include(node)
+          return unless range_include(node)
+
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,7 +7,7 @@ module RuboCop
       # where `yield` would do just as well.
       #
       # @example
-      #   @bad
+      #   # bad
       #   def method(&block)
       #     block.call
       #   end
@@ -16,7 +15,7 @@ module RuboCop
       #     func.call 1, 2, 3
       #   end
       #
-      #   @good
+      #   # good
       #   def method
       #     yield
       #   end
@@ -24,53 +23,35 @@ 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
         SPACE = ' '.freeze
 
-        def_node_matcher :blockarg_def, <<-END
+        def_node_matcher :blockarg_def, <<-PATTERN
           {(def  _   (args ... (blockarg $_)) $_)
            (defs _ _ (args ... (blockarg $_)) $_)}
-        END
+        PATTERN
 
-        def_node_search :blockarg_calls, <<-END
+        def_node_search :blockarg_calls, <<-PATTERN
           (send (lvar %1) :call ...)
-        END
+        PATTERN
 
-        def_node_search :blockarg_assigned?, <<-END
+        def_node_search :blockarg_assigned?, <<-PATTERN
           (lvasgn %1 ...)
-        END
+        PATTERN
 
         def on_def(node)
           blockarg_def(node) do |argname, body|
             next unless body
 
             calls_to_report(argname, body).each do |blockcall|
-              add_offense(blockcall, :expression, 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
@@ -88,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