rubbycop 0.49.0

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 `%s_by%s` instead of ' \
+              '`%s { |%s, %s| %s <=> %s }`.'.freeze
+
+        def_node_matcher :compare?, <<-END
+          (block
+            $(send _ {:sort :min :max})
+            (args (arg $_a) (arg $_b))
+            $send)
+        END
+
+        def_node_matcher :replaceable_body?, <<-END
+          (send
+            (send (lvar %1) $_method $...)
+            :<=>
+            (send (lvar %2) _method $...))
+        END
+
+        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, range,
+                          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
+
+        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, instead,
+                 compare_method, var_a, var_b,
+                 str_a, str_b)
+        end
+
+        def compare_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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, range, 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/rubbycop/cop/performance/detect.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+          add_offense(node, range, format(message,
+                                          preferred_method,
+                                          first_method,
+                                          second_method))
+        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/rubbycop/cop/performance/double_start_end_with.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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)
+          add_offense(node,
+                      :expression,
+                      format(
+                        MSG,
+                        receiver: receiver.source,
+                        method: method,
+                        combined_args: combined_args,
+                        original_code: node.source
+                      ))
+        end
+
+        def check_for_active_support_aliases?
+          cop_config['IncludeActiveSupportAliases']
+        end
+
+        def_node_matcher :two_start_end_with_calls, <<-END
+          (or
+            (send $_recv [{:start_with? :end_with?} $_method] $...)
+            (send _recv _method $...))
+        END
+
+        def_node_matcher :check_with_active_support_aliases, <<-END
+          (or
+            (send $_recv
+                    [{:start_with? :starts_with? :end_with? :ends_with?} $_method]
+                  $...)
+            (send _recv _method $...))
+        END
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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?, <<-END
+          {(send $!nil {:match :=~} (regexp (str $#literal_at_end?) (regopt)))
+           (send (regexp (str $#literal_at_end?) (regopt)) {:match :=~} $_)}
+        END
+
+        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, :expression)
+        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