rubocop 0.67.2 → 0.68.0

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where a case-insensitive string comparison
-      # can better be implemented using `casecmp`.
-      #
-      # @example
-      #   # bad
-      #   str.downcase == 'abc'
-      #   str.upcase.eql? 'ABC'
-      #   'abc' == str.downcase
-      #   'ABC'.eql? str.upcase
-      #   str.downcase == str.downcase
-      #
-      #   # good
-      #   str.casecmp('ABC').zero?
-      #   'abc'.casecmp(str).zero?
-      class Casecmp < Cop
-        MSG = 'Use `%<good>s` instead of `%<bad>s`.'.freeze
-        CASE_METHODS = %i[downcase upcase].freeze
-
-        def_node_matcher :downcase_eq, <<-PATTERN
-          (send
-            $(send _ ${:downcase :upcase})
-            ${:== :eql? :!=}
-            ${str (send _ {:downcase :upcase} ...) (begin str)})
-        PATTERN
-
-        def_node_matcher :eq_downcase, <<-PATTERN
-          (send
-            {str (send _ {:downcase :upcase} ...) (begin str)}
-            ${:== :eql? :!=}
-            $(send _ ${:downcase :upcase}))
-        PATTERN
-
-        def_node_matcher :downcase_downcase, <<-PATTERN
-          (send
-            $(send _ ${:downcase :upcase})
-            ${:== :eql? :!=}
-            $(send _ ${:downcase :upcase}))
-        PATTERN
-
-        def on_send(node)
-          return unless downcase_eq(node) || eq_downcase(node)
-          return unless (parts = take_method_apart(node))
-
-          _, _, arg, variable = parts
-          good_method = build_good_method(arg, variable)
-
-          add_offense(
-            node,
-            message: format(MSG, good: good_method, bad: node.source)
-          )
-        end
-
-        def autocorrect(node)
-          return unless (parts = take_method_apart(node))
-
-          receiver, method, arg, variable = parts
-
-          correction(node, receiver, method, arg, variable)
-        end
-
-        private
-
-        def take_method_apart(node)
-          if downcase_downcase(node)
-            receiver, method, rhs = *node
-            arg, = *rhs
-          elsif downcase_eq(node)
-            receiver, method, arg = *node
-          elsif eq_downcase(node)
-            arg, method, receiver = *node
-          else
-            return
-          end
-
-          variable, = *receiver
-
-          [receiver, method, arg, variable]
-        end
-
-        def correction(node, _receiver, method, arg, variable)
-          lambda do |corrector|
-            corrector.insert_before(node.loc.expression, '!') if method == :!=
-
-            replacement = build_good_method(arg, variable)
-
-            corrector.replace(node.loc.expression, replacement)
-          end
-        end
-
-        def build_good_method(arg, variable)
-          # We want resulting call to be parenthesized
-          # if arg already includes one or more sets of parens, don't add more
-          # or if method call already used parens, again, don't add more
-          if arg.send_type? || !parentheses?(arg)
-            "#{variable.source}.casecmp(#{arg.source}).zero?"
-          else
-            "#{variable.source}.casecmp#{arg.source}.zero?"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of
-      # @example
-      #   # bad
-      #   array = ["a", "b", "c"]
-      #   array.compact.flatten.map { |x| x.downcase }
-      #
-      # Each of these methods (`compact`, `flatten`, `map`) will generate a
-      # new intermediate array that is promptly thrown away. Instead it is
-      # faster to mutate when we know it's safe.
-      #
-      # @example
-      #   # good.
-      #   array = ["a", "b", "c"]
-      #   array.compact!
-      #   array.flatten!
-      #   array.map! { |x| x.downcase }
-      #   array
-      class ChainArrayAllocation < Cop
-        include RangeHelp
-
-        # These methods return a new array but only sometimes. They must be
-        # called with an argument. For example:
-        #
-        #   [1,2].first    # => 1
-        #   [1,2].first(1) # => [1]
-        #
-        RETURN_NEW_ARRAY_WHEN_ARGS = ':first :last :pop :sample :shift '.freeze
-
-        # These methods return a new array only when called without a block.
-        RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = ':zip :product '.freeze
-
-        # These methods ALWAYS return a new array
-        # after they're called it's safe to mutate the the resulting array
-        ALWAYS_RETURNS_NEW_ARRAY = ':* :+ :- :collect :compact :drop '\
-                                   ':drop_while :flatten :map :reject ' \
-                                   ':reverse :rotate :select :shuffle :sort ' \
-                                   ':take :take_while :transpose :uniq ' \
-                                   ':values_at :| '.freeze
-
-        # These methods have a mutation alternative. For example :collect
-        # can be called as :collect!
-        HAS_MUTATION_ALTERNATIVE = ':collect :compact :flatten :map :reject '\
-                                   ':reverse :rotate :select :shuffle :sort '\
-                                   ':uniq '.freeze
-        MSG = 'Use unchained `%<method>s!` and `%<second_method>s!` '\
-              '(followed by `return array` if required) instead of chaining '\
-              '`%<method>s...%<second_method>s`.'.freeze
-
-        def_node_matcher :flat_map_candidate?, <<-PATTERN
-          {
-            (send (send _ ${#{RETURN_NEW_ARRAY_WHEN_ARGS}} {int lvar ivar cvar gvar}) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
-            (send (block (send _ ${#{ALWAYS_RETURNS_NEW_ARRAY} }) ...) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
-            (send (send _ ${#{ALWAYS_RETURNS_NEW_ARRAY + RETURNS_NEW_ARRAY_WHEN_NO_BLOCK}} ...) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
-          }
-        PATTERN
-
-        def on_send(node)
-          flat_map_candidate?(node) do |fm, sm, _|
-            range = range_between(
-              node.loc.dot.begin_pos,
-              node.source_range.end_pos
-            )
-            add_offense(
-              node,
-              location: range,
-              message: format(MSG, method: fm, second_method: sm)
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,122 +0,0 @@
-# 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
-        include RangeHelp
-
-        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,102 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of `count` on an `Enumerable` that
-      # follow calls to `select` or `reject`. Querying logic can instead be
-      # passed to the `count` call.
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3].select { |e| e > 2 }.size
-      #   [1, 2, 3].reject { |e| e > 2 }.size
-      #   [1, 2, 3].select { |e| e > 2 }.length
-      #   [1, 2, 3].reject { |e| e > 2 }.length
-      #   [1, 2, 3].select { |e| e > 2 }.count { |e| e.odd? }
-      #   [1, 2, 3].reject { |e| e > 2 }.count { |e| e.even? }
-      #   array.select(&:value).count
-      #
-      #   # good
-      #   [1, 2, 3].count { |e| e > 2 }
-      #   [1, 2, 3].count { |e| e < 2 }
-      #   [1, 2, 3].count { |e| e > 2 && e.odd? }
-      #   [1, 2, 3].count { |e| e < 2 && e.even? }
-      #   Model.select('field AS field_one').count
-      #   Model.select(:value).count
-      #
-      # `ActiveRecord` compatibility:
-      # `ActiveRecord` will ignore the block that is passed to `count`.
-      # Other methods, such as `select`, will convert the association to an
-      # array and then run the block on the array. A simple work around to
-      # make `count` work with a block is to call `to_a.count {...}`.
-      #
-      # Example:
-      #   Model.where(id: [1, 2, 3].select { |m| m.method == true }.size
-      #
-      #   becomes:
-      #
-      #   Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }
-      class Count < Cop
-        include SafeMode
-        include RangeHelp
-
-        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 if rails_safe_mode?
-
-          count_candidate?(node) do |selector_node, selector, counter|
-            return unless eligible_node?(node)
-
-            range = source_starting_at(node) do
-              selector_node.loc.selector.begin_pos
-            end
-
-            add_offense(node,
-                        location: range,
-                        message: format(MSG, selector: selector,
-                                             counter: counter))
-          end
-        end
-
-        def autocorrect(node)
-          selector_node, selector, _counter = count_candidate?(node)
-          selector_loc = selector_node.loc.selector
-
-          return if selector == :reject
-
-          range = source_starting_at(node) { |n| n.loc.dot.begin_pos }
-
-          lambda do |corrector|
-            corrector.remove(range)
-            corrector.replace(selector_loc, 'count')
-          end
-        end
-
-        private
-
-        def eligible_node?(node)
-          !(node.parent && node.parent.block_type?)
-        end
-
-        def source_starting_at(node)
-          begin_pos = if block_given?
-                        yield node
-                      else
-                        node.source_range.begin_pos
-                      end
-
-          range_between(begin_pos, node.source_range.end_pos)
-        end
-      end
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of
-      # `select.first`, `select.last`, `find_all.first`, and `find_all.last`
-      # and change them to use `detect` instead.
-      #
-      # @example
-      #   # bad
-      #   [].select { |item| true }.first
-      #   [].select { |item| true }.last
-      #   [].find_all { |item| true }.first
-      #   [].find_all { |item| true }.last
-      #
-      #   # good
-      #   [].detect { |item| true }
-      #   [].reverse.detect { |item| true }
-      #
-      # `ActiveRecord` compatibility:
-      # `ActiveRecord` does not implement a `detect` method and `find` has its
-      # own meaning. Correcting ActiveRecord methods with this cop should be
-      # considered unsafe.
-      class Detect < Cop
-        include SafeMode
-
-        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 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)
-
-            register_offense(node, receiver, second_method)
-          end
-        end
-
-        def autocorrect(node)
-          receiver, first_method = *node
-
-          replacement = if first_method == :last
-                          "reverse.#{preferred_method}"
-                        else
-                          preferred_method
-                        end
-
-          first_range = receiver.source_range.end.join(node.loc.selector)
-
-          receiver, _args, _body = *receiver if receiver.block_type?
-
-          lambda do |corrector|
-            corrector.remove(first_range)
-            corrector.replace(receiver.loc.selector, replacement)
-          end
-        end
-
-        private
-
-        def accept_first_call?(receiver, body)
-          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?)
-
-          lazy?(caller)
-        end
-
-        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
-          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
-          config.for_cop('Style/CollectionMethods') \
-            ['PreferredMethods']['detect'] || 'detect'
-        end
-
-        def lazy?(node)
-          return false unless node
-
-          receiver, method, _args = *node
-          method == :lazy && !receiver.nil?
-        end
-      end
-    end
-  end
-end