rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -52,41 +51,29 @@ module RuboCop
       #     baz
       #   end
       class CaseWhenSplat < Cop
-        include AutocorrectAlignment
+        include Alignment
 
         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(node)
-          _case_branch, *when_branches, _else_branch = *node
-          when_conditions =
-            when_branches.each_with_object([]) do |branch, conditions|
-              *condition, _ = *branch
-              condition.each { |c| conditions << c }
-            end
+
+        def on_case(case_node)
+          when_conditions = case_node.when_branches.flat_map(&:conditions)
 
           splat_offenses(when_conditions).reverse_each do |condition|
             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
 
-        def autocorrect(node)
-          *conditions, _body = *node
-
+        def autocorrect(when_node)
           lambda do |corrector|
-            if needs_reorder?(conditions)
-              reorder_condition(corrector, node, replacement(conditions))
+            if needs_reorder?(when_node)
+              reorder_condition(corrector, when_node)
             else
-              inline_fix_branch(corrector, node, conditions,
-                                replacement(conditions))
+              inline_fix_branch(corrector, when_node)
             end
           end
         end
@@ -94,100 +81,89 @@ module RuboCop
         private
 
         def replacement(conditions)
-          new_condition = conditions.map do |condition|
-            variable, = *condition
-            if variable.respond_to?(:array_type?) && variable.array_type?
-              expand_percent_array(variable)
-            else
-              condition.source
-            end
-          end
+          reordered = conditions.partition(&:splat_type?).reverse
+          reordered.flatten.map(&:source).join(', ')
+        end
+
+        def inline_fix_branch(corrector, when_node)
+          conditions = when_node.conditions
+          range = range_between(conditions[0].loc.expression.begin_pos,
+                                conditions[-1].loc.expression.end_pos)
 
-          new_condition.join(', ')
+          corrector.replace(range, replacement(conditions))
         end
 
-        def inline_fix_branch(corrector, node, conditions, new_condition)
-          range =
-            Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                      conditions[0].loc.expression.begin_pos,
-                                      conditions[-1].loc.expression.end_pos)
-          corrector.replace(range, new_condition)
+        def reorder_condition(corrector, when_node)
+          when_branches = when_node.parent.when_branches
+
+          return if when_branches.one?
+
+          corrector.remove(when_branch_range(when_node))
+          corrector.insert_after(when_branches.last.source_range,
+                                 reordering_correction(when_node))
         end
 
-        def reorder_condition(corrector, node, new_condition)
-          *_conditions, body = *node
-          parent = node.parent
-          _case_branch, *when_branches, _else_branch = *parent
-          current_index = when_branches.index { |branch| branch == node }
-          next_branch = when_branches[current_index + 1]
-          range = Parser::Source::Range.new(parent,
-                                            node.source_range.begin_pos,
-                                            next_branch.source_range.begin_pos)
-
-          corrector.remove(range)
-
-          correction = if same_line?(node, body)
-                         new_condition_with_then(node, new_condition)
-                       else
-                         new_branch_without_then(node, body, new_condition)
-                       end
-
-          corrector.insert_after(when_branches.last.source_range, correction)
+        def reordering_correction(when_node)
+          new_condition = replacement(when_node.conditions)
+
+          if same_line?(when_node, when_node.body)
+            new_condition_with_then(when_node, new_condition)
+          else
+            new_branch_without_then(when_node, new_condition)
+          end
         end
 
-        def same_line?(node, other)
-          node.loc.first_line == other.loc.first_line
+        def when_branch_range(when_node)
+          next_branch =
+            when_node.parent.when_branches[when_node.branch_index + 1]
+
+          range_between(when_node.source_range.begin_pos,
+                        next_branch.source_range.begin_pos)
         end
 
         def new_condition_with_then(node, new_condition)
-          "\n#{' ' * node.loc.column}when " \
-            "#{new_condition} then #{node.children.last.source}"
+          "\n#{indent_for(node)}when " \
+          "#{new_condition} then #{node.body.source}"
+        end
+
+        def new_branch_without_then(node, new_condition)
+          "\n#{indent_for(node)}when #{new_condition}" \
+          "\n#{indent_for(node.body)}#{node.body.source}"
         end
 
-        def new_branch_without_then(node, body, new_condition)
-          "\n#{' ' * node.loc.column}when #{new_condition}\n" \
-            "#{' ' * body.loc.column}#{node.children.last.source}"
+        def indent_for(node)
+          ' ' * node.loc.column
         end
 
         def splat_offenses(when_conditions)
           found_non_splat = false
-          when_conditions.reverse.each_with_object([]) do |condition, result|
-            found_non_splat ||= error_condition?(condition)
 
-            next unless condition.splat_type?
-            result << condition if found_non_splat
+          offenses = when_conditions.reverse.map do |condition|
+            found_non_splat ||= non_splat?(condition)
+
+            next if non_splat?(condition)
+
+            condition if found_non_splat
           end
+
+          offenses.compact
         end
 
-        def error_condition?(condition)
+        def non_splat?(condition)
           variable, = *condition
 
           (condition.splat_type? && variable.array_type?) ||
             !condition.splat_type?
         end
 
-        def needs_reorder?(conditions)
-          conditions.any? do |condition|
-            variable, = *condition
-            condition.splat_type? && !(variable && variable.array_type?)
-          end
-        end
+        def needs_reorder?(when_node)
+          following_branches =
+            when_node.parent.when_branches[(when_node.branch_index + 1)..-1]
 
-        def expand_percent_array(array)
-          array_start = array.loc.begin.source
-          elements = *array
-          elements = elements.map(&:source)
-
-          if array_start.start_with?(PERCENT_W)
-            "'#{elements.join("', '")}'"
-          elsif array_start.start_with?(PERCENT_CAPITAL_W)
-            %("#{elements.join('", "')}")
-          elsif array_start.start_with?(PERCENT_I)
-            ":#{elements.join(', :')}"
-          elsif array_start.start_with?(PERCENT_CAPITAL_I)
-            %(:"#{elements.join('", :"')}")
-          else
-            elements.join(', ')
+          following_branches.any? do |when_branch|
+            when_branch.conditions.any? do |condition|
+              non_splat?(condition)
+            end
           end
         end
       end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,53 +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
-        CASE_METHODS = [:downcase, :upcase].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)
 
-          downcase_eq(node) do |send_downcase, case_method, eq_method, other|
-            *_, method = *other
-            if CASE_METHODS.include?(method)
-              range = node.loc.expression
-              ignore_node(node)
-            else
-              range = node.loc.selector.join(send_downcase.loc.selector)
-            end
-
-            add_offense(node, range, format(MSG, case_method, eq_method))
-            return
-          end
-
-          eq_downcase(node) do |eq_method, send_downcase, case_method|
-            range = node.loc.selector.join(send_downcase.loc.selector)
-            add_offense(node, range, format(MSG, eq_method, case_method))
+          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: methods.join(' ')))
           end
         end
 
@@ -74,6 +61,31 @@ module RuboCop
 
         private
 
+        def inefficient_comparison(node)
+          loc = node.loc
+
+          downcase_eq(node) do |send_downcase, case_method, eq_method, other|
+            *_, method = *other
+            range, is_other_part = downcase_eq_range(method, loc, send_downcase)
+
+            yield range, is_other_part, case_method, eq_method
+            return
+          end
+
+          eq_downcase(node) do |eq_method, send_downcase, case_method|
+            range = loc.selector.join(send_downcase.loc.selector)
+            yield range, false, eq_method, case_method
+          end
+        end
+
+        def downcase_eq_range(method, loc, send_downcase)
+          if CASE_METHODS.include?(method)
+            [loc.expression, true]
+          else
+            [loc.selector.join(send_downcase.loc.selector), false]
+          end
+        end
+
         def correction(node, _receiver, method, arg, variable)
           lambda do |corrector|
             corrector.insert_before(node.loc.expression, '!') if method == :!=

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `sort { |a, b| a.foo <=> b.foo }`
+      # can be replaced by `sort_by(&:foo)`.
+      # This cop also checks `max` and `min` methods.
+      #
+      # @example
+      #   # 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
+      #   array.sort_by(&:foo)
+      #   array.sort_by { |v| v.foo }
+      #   array.sort_by do |var|
+      #     var.foo
+      #   end
+      #   array.max_by(&:foo)
+      #   array.min_by(&:foo)
+      #   array.sort_by { |a| a[:foo] }
+      class CompareWithBlock < Cop
+        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
+            $(send _ {:sort :min :max})
+            (args (arg $_a) (arg $_b))
+            $send)
+        PATTERN
+
+        def_node_matcher :replaceable_body?, <<-PATTERN
+          (send
+            (send (lvar %1) $_method $...)
+            :<=>
+            (send (lvar %2) _method $...))
+        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,
+                location: range,
+                message: message(send, method, var_a, var_b, args_a)
+              )
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            send, var_a, var_b, body = compare?(node)
+            method, arg, = replaceable_body?(body, var_a, var_b)
+            replacement =
+              if method == :[]
+                "#{send.method_name}_by { |a| a[#{arg.first.source}] }"
+              else
+                "#{send.method_name}_by(&:#{method})"
+              end
+            corrector.replace(compare_range(send, node),
+                              replacement)
+          end
+        end
+
+        private
+
+        def slow_compare?(method, args_a, args_b)
+          return false unless args_a == args_b
+          if method == :[]
+            return false unless args_a.size == 1
+            key = args_a.first
+            return false unless %i[sym str int].include?(key.type)
+          else
+            return false unless args_a.empty?
+          end
+          true
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def message(send, method, var_a, var_b, args)
+          compare_method = send.method_name
+          if method == :[]
+            key = args.first
+            instead = " { |a| a[#{key.source}] }"
+            str_a = "#{var_a}[#{key.source}]"
+            str_b = "#{var_b}[#{key.source}]"
+          else
+            instead = "(&:#{method})"
+            str_a = "#{var_a}.#{method}"
+            str_b = "#{var_b}.#{method}"
+          end
+          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)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -39,34 +38,41 @@ module RuboCop
       #
       #   Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }
       class Count < Cop
-        MSG = 'Use `count` instead of `%s...%s`.'.freeze
+        include SafeMode
 
-        SELECTORS = [:reject, :select].freeze
-        COUNTERS = [:count, :length, :size].freeze
+        MSG = 'Use `count` instead of `%<selector>s...%<counter>s`.'.freeze
+
+        def_node_matcher :count_candidate?, <<-PATTERN
+          {
+            (send (block $(send _ ${:select :reject}) ...) ${:count :length :size})
+            (send $(send _ ${:select :reject} (:block_pass _)) ${:count :length :size})
+          }
+        PATTERN
 
         def on_send(node)
-          return unless should_run?
-          selector, selector_loc, params, counter = parse(node)
-          return unless COUNTERS.include?(counter)
-          return unless SELECTORS.include?(selector)
-          return if params && !params.block_pass_type?
-          return if node.parent && node.parent.block_type?
+          return if rails_safe_mode?
+
+          count_candidate?(node) do |selector_node, selector, counter|
+            return unless eligible_node?(node)
 
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            selector_loc.begin_pos,
-                                            node.source_range.end_pos)
+            range = source_starting_at(node) do
+              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
 
         def autocorrect(node)
-          selector, selector_loc = parse(node)
+          selector_node, selector, _counter = count_candidate?(node)
+          selector_loc = selector_node.loc.selector
 
           return if selector == :reject
 
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            node.loc.dot.begin_pos,
-                                            node.source_range.end_pos)
+          range = source_starting_at(node) { |n| n.loc.dot.begin_pos }
 
           lambda do |corrector|
             corrector.remove(range)
@@ -76,34 +82,18 @@ module RuboCop
 
         private
 
-        def should_run?
-          !(cop_config['SafeMode'.freeze] ||
-            config['Rails'.freeze] &&
-            config['Rails'.freeze]['Enabled'.freeze])
+        def eligible_node?(node)
+          !(node.parent && node.parent.block_type?)
         end
 
-        def parse(node)
-          left, counter = *node
-          expression, selector, params = *left
-
-          selector_loc =
-            if selector.is_a?(Symbol)
-              if expression && expression.parent.loc.respond_to?(:selector)
-                expression.parent.loc.selector
-              elsif left.loc.respond_to?(:selector)
-                left.loc.selector
-              end
-            else
-              _enumerable, selector, params = *expression
-
-              expression.loc.selector if contains_selector?(expression)
-            end
-
-          [selector, selector_loc, params, counter]
-        end
+        def source_starting_at(node)
+          begin_pos = if block_given?
+                        yield node
+                      else
+                        node.source_range.begin_pos
+                      end
 
-        def contains_selector?(node)
-          node.respond_to?(:loc) && node.loc.respond_to?(:selector)
+          range_between(begin_pos, node.source_range.end_pos)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -24,21 +23,32 @@ module RuboCop
       # own meaning. Correcting ActiveRecord methods with this cop should be
       # considered unsafe.
       class Detect < Cop
-        MSG = 'Use `%s` instead of `%s.%s`.'.freeze
-        REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%s`.'.freeze
+        include SafeMode
 
-        SELECT_METHODS = [:select, :find_all].freeze
-        DANGEROUS_METHODS = [:first, :last].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
+          {
+            (send $(block (send _ {:select :find_all}) ...) ${:first :last} $...)
+            (send $(send _ {:select :find_all} ...) ${:first :last} $...)
+          }
+        PATTERN
 
         def on_send(node)
-          return unless should_run?
-          receiver, second_method, *args = *node
-          return if accept_second_call?(receiver, second_method, args)
+          return if rails_safe_mode?
+
+          detect_candidate?(node) do |receiver, second_method, args|
+            return unless args.empty?
+            return unless receiver
 
-          receiver, _args, body = *receiver if receiver.block_type?
-          return if accept_first_call?(receiver, body)
+            receiver, _args, body = *receiver if receiver.block_type?
+            return if accept_first_call?(receiver, body)
 
-          offense(node, receiver, second_method)
+            register_offense(node, receiver, second_method)
+          end
         end
 
         def autocorrect(node)
@@ -62,37 +72,25 @@ module RuboCop
 
         private
 
-        def should_run?
-          !(cop_config['SafeMode'.freeze] ||
-            config['Rails'.freeze] &&
-            config['Rails'.freeze]['Enabled'.freeze])
-        end
-
-        def accept_second_call?(receiver, method, args)
-          !receiver ||
-            !DANGEROUS_METHODS.include?(method) ||
-            !args.empty?
-        end
-
         def accept_first_call?(receiver, body)
-          caller, first_method, args = *receiver
+          caller, _first_method, args = *receiver
 
           # check that we have usual block or block pass
           return true if body.nil? && (args.nil? || !args.block_pass_type?)
-          return true unless SELECT_METHODS.include?(first_method)
 
           lazy?(caller)
         end
 
-        def offense(node, receiver, second_method)
+        def register_offense(node, receiver, second_method)
           _caller, first_method, _args = *receiver
           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
@@ -101,7 +99,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