rubocop 0.51.0 → 0.87.0

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

@@ -1,100 +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
-
-        MSG = 'Use `count` instead of `%s...%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, counter))
-          end
-        end
-
-        private
-
-        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
-
-        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,107 +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 `%s` instead of `%s.%s`.'.freeze
-        REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%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, preferred_method, first_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

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop checks for double `#start_with?` or `#end_with?` calls
-      # separated by `||`. In some cases such calls can be replaced
-      # with an single `#start_with?`/`#end_with?` call.
-      #
-      # @example
-      #
-      #   @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
-      #   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>s.%<method>s(%<combined_args>s)` ' \
-              'instead of `%<original_code>s`.'.freeze
-
-        def on_or(node)
-          receiver,
-          method,
-          first_call_args,
-          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 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 $...))
-        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
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies unnecessary use of a regex where `String#end_with?`
-      # would suffice.
-      #
-      # @example
-      #   @bad
-      #   'abc' =~ /bc\Z/
-      #   'abc'.match(/bc\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?, <<-PATTERN
-          {(send $!nil? {:match :=~} (regexp (str $#literal_at_end?) (regopt)))
-           (send (regexp (str $#literal_at_end?) (regopt)) {:match :=~} $_)}
-        PATTERN
-
-        def literal_at_end?(regex_str)
-          # is this regexp 'literal' in the sense of only matching literal
-          # chars, rather than using metachars like . and * and so on?
-          # also, is it anchored at the end of the string?
-          regex_str =~ /\A(?:#{LITERAL_REGEX})+\\z\z/
-        end
-
-        def on_send(node)
-          return unless redundant_regex?(node)
-
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          redundant_regex?(node) do |receiver, regex_str|
-            receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
-            regex_str = regex_str[0..-3] # drop \Z anchor
-            regex_str = interpret_string_escapes(regex_str)
-
-            lambda do |corrector|
-              new_source = receiver.source + '.end_with?(' +
-                           to_string_literal(regex_str) + ')'
-              corrector.replace(node.source_range, new_source)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Do not compute the size of statically sized objects.
-      class FixedSize < Cop
-        MSG = 'Do not compute the size of statically sized objects.'.freeze
-
-        def_node_matcher :counter, <<-MATCHER
-          (send ${array hash str sym} {:count :length :size} $...)
-        MATCHER
-
-        def on_send(node)
-          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.each_child_node(:splat).any?
-        end
-
-        def contains_double_splat?(node)
-          return unless node.hash_type?
-
-          node.each_child_node(:kwsplat).any?
-        end
-
-        def non_string_argument?(node)
-          node && !node.str_type?
-        end
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3, 4].map { |e| [e, e] }.flatten(1)
-      #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten(1)
-      #
-      #   # good
-      #   [1, 2, 3, 4].flat_map { |e| [e, e] }
-      #   [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
-        FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
-                                  'and `flatten` can be used to flatten ' \
-                                  'multiple levels.'.freeze
-
-        def_node_matcher :flat_map_candidate?, <<-PATTERN
-          (send (block $(send _ ${:collect :map}) ...) ${:flatten :flatten!} $...)
-        PATTERN
-
-        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)
-          map_node, _first_method, _flatten, params = flat_map_candidate?(node)
-          flatten_level, = *params.first
-
-          return unless flatten_level
-
-          range = range_between(node.loc.dot.begin_pos,
-                                node.source_range.end_pos)
-
-          lambda do |corrector|
-            corrector.remove(range)
-            corrector.replace(map_node.loc.selector, 'flat_map')
-          end
-        end
-
-        private
-
-        def offense_for_levels(node, map_node, first_method, flatten)
-          message = MSG + FLATTEN_MULTIPLE_LEVELS
-          register_offense(node, map_node, first_method, flatten, message)
-        end
-
-        def offense_for_method(node, map_node, first_method, flatten)
-          register_offense(node, map_node, first_method, flatten, MSG)
-        end
-
-        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,
-                      location: range,
-                      message: format(message, first_method, flatten))
-        end
-      end
-    end
-  end
-end

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

@@ -1,128 +0,0 @@
-# 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 supress 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 `%s` instead of `%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
-
-        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,
-              location: plain_range(target),
-              message: format(message, "each_#{used}", :each)
-            )
-          end
-        end
-
-        def register_kv_offense(node)
-          kv_each(node) do |target, method|
-            msg = format(message, "each_#{method[0..-2]}", "#{method}.each")
-
-            add_offense(target, location: kv_range(target), message: msg)
-          end
-        end
-
-        def check_argument(variable)
-          return unless variable.block_argument?
-          (@args ||= {})[variable.name] = variable.used?
-        end
-
-        def autocorrect(node)
-          receiver, _second_method = *node
-          _caller, first_method = *receiver
-
-          lambda do |corrector|
-            case first_method
-            when :keys, :values
-              return correct_implicit(node, corrector) if receiver.receiver.nil?
-
-              correct_key_value_each(node, corrector)
-            else
-              return correct_implicit(node, corrector) if receiver.nil?
-
-              correct_plain_each(node, corrector)
-            end
-          end
-        end
-
-        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}|"
-
-          corrector.replace(args.source_range, used_arg)
-        end
-
-        def plain_range(outer_node)
-          outer_node.loc.selector
-        end
-
-        def kv_range(outer_node)
-          inner_node = outer_node.children.first
-          inner_node.loc.selector.join(outer_node.loc.selector)
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies uses of `Range#include?`, which iterates over each
-      # item in a `Range` to see if a specified item is there. In contrast,
-      # `Range#cover?` simply compares the target item with the beginning and
-      # end points of the `Range`. In a great majority of cases, this is what
-      # is wanted.
-      #
-      # Here is an example of a case where `Range#cover?` may not provide the
-      # desired result:
-      #
-      #     ('a'..'z').cover?('yellow') # => true
-      #
-      class RangeInclude < Cop
-        MSG = 'Use `Range#cover?` instead of `Range#include?`.'.freeze
-
-        # TODO: If we traced out assignments of variables to their uses, we
-        # might pick up on a few more instances of this issue
-        # 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, <<-PATTERN
-          (send {irange erange (begin {irange erange})} :include? ...)
-        PATTERN
-
-        def on_send(node)
-          return unless range_include(node)
-
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'cover?') }
-        end
-      end
-    end
-  end
-end