rubocop-performance 0.0.0

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `sort_by { ... }` can be replaced by
+      # `sort`.
+      #
+      # @example
+      #   # bad
+      #   array.sort_by { |x| x }
+      #   array.sort_by do |var|
+      #     var
+      #   end
+      #
+      #   # good
+      #   array.sort
+      class RedundantSortBy < Cop
+        include RangeHelp
+
+        MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'.freeze
+
+        def_node_matcher :redundant_sort_by, <<-PATTERN
+          (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
+        PATTERN
+
+        def on_block(node)
+          redundant_sort_by(node) do |send, var_name|
+            range = sort_by_range(send, node)
+
+            add_offense(node,
+                        location: range,
+                        message: format(MSG, var: var_name))
+          end
+        end
+
+        def autocorrect(node)
+          send, = *node
+          ->(corrector) { corrector.replace(sort_by_range(send, node), 'sort') }
+        end
+
+        private
+
+        def sort_by_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/regexp_match.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # In Ruby 2.4, `String#match?`, `Regexp#match?` and `Symbol#match?`
+      # have been added. The methods are faster than `match`.
+      # Because the methods avoid creating a `MatchData` object or saving
+      # backref.
+      # So, when `MatchData` is not used, use `match?` instead of `match`.
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     if x =~ /re/
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     if x !~ /re/
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     if x.match(/re/)
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     if /re/ === x
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if x.match?(/re/)
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if !x.match?(/re/)
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if x =~ /re/
+      #       do_something(Regexp.last_match)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if x.match(/re/)
+      #       do_something($~)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if /re/ === x
+      #       do_something($~)
+      #     end
+      #   end
+      class RegexpMatch < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
+
+        # Constants are included in this list because it is unlikely that
+        # someone will store `nil` as a constant and then use it for comparison
+        TYPES_IMPLEMENTING_MATCH = %i[const regexp str sym].freeze
+        MSG =
+          'Use `match?` instead of `%<current>s` when `MatchData` ' \
+          'is not used.'.freeze
+
+        def_node_matcher :match_method?, <<-PATTERN
+          {
+            (send _recv :match _)
+            (send _recv :match _ (int ...))
+          }
+        PATTERN
+
+        def_node_matcher :match_operator?, <<-PATTERN
+          (send !nil? {:=~ :!~} !nil?)
+        PATTERN
+
+        def_node_matcher :match_threequals?, <<-PATTERN
+          (send (regexp (str _) {(regopt) (regopt _)}) :=== !nil?)
+        PATTERN
+
+        def match_with_lvasgn?(node)
+          return false unless node.match_with_lvasgn_type?
+          regexp, _rhs = *node
+          regexp.to_regexp.named_captures.empty?
+        end
+
+        MATCH_NODE_PATTERN = <<-PATTERN.freeze
+          {
+            #match_method?
+            #match_operator?
+            #match_threequals?
+            #match_with_lvasgn?
+          }
+        PATTERN
+
+        def_node_matcher :match_node?, MATCH_NODE_PATTERN
+        def_node_search :search_match_nodes, MATCH_NODE_PATTERN
+
+        def_node_search :last_matches, <<-PATTERN
+          {
+            (send (const nil? :Regexp) :last_match)
+            (send (const nil? :Regexp) :last_match _)
+            ({back_ref nth_ref} _)
+            (gvar #match_gvar?)
+          }
+        PATTERN
+
+        def on_if(node)
+          check_condition(node.condition)
+        end
+
+        def on_case(node)
+          return if node.condition
+
+          node.each_when do |when_node|
+            when_node.each_condition do |condition|
+              check_condition(condition)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if match_method?(node)
+              corrector.replace(node.loc.selector, 'match?')
+            elsif match_operator?(node) || match_threequals?(node)
+              recv, oper, arg = *node
+              correct_operator(corrector, recv, arg, oper)
+            elsif match_with_lvasgn?(node)
+              recv, arg = *node
+              correct_operator(corrector, recv, arg)
+            end
+          end
+        end
+
+        private
+
+        def check_condition(cond)
+          match_node?(cond) do
+            return if last_match_used?(cond)
+
+            add_offense(cond)
+          end
+        end
+
+        def message(node)
+          format(MSG, current: node.loc.selector.source)
+        end
+
+        def last_match_used?(match_node)
+          scope_root = scope_root(match_node)
+          body = scope_root ? scope_body(scope_root) : match_node.ancestors.last
+
+          return true if match_node.parent.if_type? &&
+                         match_node.parent.modifier_form?
+
+          match_node_pos = match_node.loc.expression.begin_pos
+
+          next_match_pos = next_match_pos(body, match_node_pos, scope_root)
+          range = match_node_pos..next_match_pos
+
+          find_last_match(body, range, scope_root)
+        end
+
+        def next_match_pos(body, match_node_pos, scope_root)
+          node = search_match_nodes(body).find do |match|
+            match.loc.expression.begin_pos > match_node_pos &&
+              scope_root(match) == scope_root
+          end
+          node ? node.loc.expression.begin_pos : Float::INFINITY
+        end
+
+        def find_last_match(body, range, scope_root)
+          last_matches(body).find do |ref|
+            ref_pos = ref.loc.expression.begin_pos
+            range.cover?(ref_pos) &&
+              scope_root(ref) == scope_root
+          end
+        end
+
+        def scope_body(node)
+          children = node.children
+          case node.type
+          when :module
+            children[1]
+          when :defs
+            children[3]
+          else
+            children[2]
+          end
+        end
+
+        def scope_root(node)
+          node.each_ancestor.find do |ancestor|
+            ancestor.def_type? ||
+              ancestor.defs_type? ||
+              ancestor.class_type? ||
+              ancestor.module_type?
+          end
+        end
+
+        def match_gvar?(sym)
+          %i[
+            $~
+            $MATCH
+            $PREMATCH
+            $POSTMATCH
+            $LAST_PAREN_MATCH
+            $LAST_MATCH_INFO
+          ].include?(sym)
+        end
+
+        def correct_operator(corrector, recv, arg, oper = nil)
+          op_range = correction_range(recv, arg)
+
+          if TYPES_IMPLEMENTING_MATCH.include?(recv.type)
+            corrector.replace(op_range, '.match?(')
+          elsif TYPES_IMPLEMENTING_MATCH.include?(arg.type)
+            corrector.replace(op_range, '.match?(')
+            swap_receiver_and_arg(corrector, recv, arg)
+          else
+            corrector.replace(op_range, '&.match?(')
+          end
+
+          corrector.insert_after(arg.loc.expression, ')')
+          corrector.insert_before(recv.loc.expression, '!') if oper == :!~
+        end
+
+        def swap_receiver_and_arg(corrector, recv, arg)
+          corrector.replace(recv.loc.expression, arg.source)
+          corrector.replace(arg.loc.expression, recv.source)
+        end
+
+        def correction_range(recv, arg)
+          buffer = processed_source.buffer
+          op_begin_pos = recv.loc.expression.end_pos
+          op_end_pos = arg.loc.expression.begin_pos
+          Parser::Source::Range.new(buffer, op_begin_pos, op_end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of `reverse.each` and
+      # change them to use `reverse_each` instead.
+      #
+      # @example
+      #   # bad
+      #   [].reverse.each
+      #
+      #   # good
+      #   [].reverse_each
+      class ReverseEach < Cop
+        include RangeHelp
+
+        MSG = 'Use `reverse_each` instead of `reverse.each`.'.freeze
+        UNDERSCORE = '_'.freeze
+
+        def_node_matcher :reverse_each?, <<-MATCHER
+          (send $(send _ :reverse) :each)
+        MATCHER
+
+        def on_send(node)
+          reverse_each?(node) do |receiver|
+            location_of_reverse = receiver.loc.selector.begin_pos
+            end_location = node.loc.selector.end_pos
+
+            range = range_between(location_of_reverse, end_location)
+
+            add_offense(node, location: range)
+          end
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.dot, UNDERSCORE) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of `shuffle.first`, `shuffle.last`
+      # and `shuffle[]` and change them to use `sample` instead.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].shuffle.first
+      #   [1, 2, 3].shuffle.first(2)
+      #   [1, 2, 3].shuffle.last
+      #   [2, 1, 3].shuffle.at(0)
+      #   [2, 1, 3].shuffle.slice(0)
+      #   [1, 2, 3].shuffle[2]
+      #   [1, 2, 3].shuffle[0, 2]    # sample(2) will do the same
+      #   [1, 2, 3].shuffle[0..2]    # sample(3) will do the same
+      #   [1, 2, 3].shuffle(random: Random.new).first
+      #
+      #   # good
+      #   [1, 2, 3].shuffle
+      #   [1, 2, 3].sample
+      #   [1, 2, 3].sample(3)
+      #   [1, 2, 3].shuffle[1, 3]    # sample(3) might return a longer Array
+      #   [1, 2, 3].shuffle[1..3]    # sample(3) might return a longer Array
+      #   [1, 2, 3].shuffle[foo, bar]
+      #   [1, 2, 3].shuffle(random: Random.new)
+      class Sample < Cop
+        MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'.freeze
+
+        def_node_matcher :sample_candidate?, <<-PATTERN
+          (send $(send _ :shuffle $...) ${:first :last :[] :at :slice} $...)
+        PATTERN
+
+        def on_send(node)
+          sample_candidate?(node) do |shuffle, shuffle_arg, method, method_args|
+            return unless offensive?(method, method_args)
+
+            range = source_range(shuffle, node)
+            message = message(shuffle_arg, method, method_args, range)
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          shuffle_node, shuffle_arg, method, method_args =
+            sample_candidate?(node)
+
+          lambda do |corrector|
+            corrector.replace(source_range(shuffle_node, node),
+                              correction(shuffle_arg, method, method_args))
+          end
+        end
+
+        private
+
+        def offensive?(method, method_args)
+          case method
+          when :first, :last
+            true
+          when :[], :at, :slice
+            sample_size(method_args) != :unknown
+          else
+            false
+          end
+        end
+
+        def sample_size(method_args)
+          case method_args.size
+          when 1
+            sample_size_for_one_arg(method_args.first)
+          when 2
+            sample_size_for_two_args(*method_args)
+          end
+        end
+
+        def sample_size_for_one_arg(arg)
+          case arg.type
+          when :erange, :irange
+            range_size(arg)
+          when :int
+            [0, -1].include?(arg.to_a.first) ? nil : :unknown
+          else
+            :unknown
+          end
+        end
+
+        def sample_size_for_two_args(first, second)
+          return :unknown unless first.int_type? && first.to_a.first.zero?
+          second.int_type? ? second.to_a.first : :unknown
+        end
+
+        def range_size(range_node)
+          vals = range_node.to_a
+          return :unknown unless vals.all?(&:int_type?)
+          low, high = vals.map { |val| val.children[0] }
+          return :unknown unless low.zero? && high >= 0
+
+          case range_node.type
+          when :erange
+            (low...high).size
+          when :irange
+            (low..high).size
+          end
+        end
+
+        def source_range(shuffle_node, node)
+          Parser::Source::Range.new(shuffle_node.source_range.source_buffer,
+                                    shuffle_node.loc.selector.begin_pos,
+                                    node.source_range.end_pos)
+        end
+
+        def message(shuffle_arg, method, method_args, range)
+          format(MSG,
+                 correct: correction(shuffle_arg, method, method_args),
+                 incorrect: range.source)
+        end
+
+        def correction(shuffle_arg, method, method_args)
+          shuffle_arg = extract_source(shuffle_arg)
+          sample_arg = sample_arg(method, method_args)
+          args = [sample_arg, shuffle_arg].compact.join(', ')
+          args.empty? ? 'sample' : "sample(#{args})"
+        end
+
+        def sample_arg(method, method_args)
+          case method
+          when :first, :last
+            extract_source(method_args)
+          when :[], :slice
+            sample_size(method_args)
+          end
+        end
+
+        def extract_source(args)
+          args.empty? ? nil : args.first.source
+        end
+      end
+    end
+  end
+end