rubocop-performance 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab4ceb1e31551e3774fc563d05282b5339c9cb132d0e9a9ce1ce6f63358cf468
+  data.tar.gz: 8d5d42ecb4e72ed9d06e30e7c609569469d4cf2fc847c8fabf602723ac8b4c21
+SHA512:
+  metadata.gz: a42a85f9011b35eae2a99ffa9763bcfa2f409079b4c1aba3e0659adb351046cc5d8c42e5b374dda1f1d78289870339ee5fe8a34460a89d38a8fe2c24589398b5
+  data.tar.gz: 2acc0104f805827d517ebca4d9a29a382642af8b53fec7691b86bb53eaabe22a29b7c1df2b91c0d53e27429430fa191788477b19545dec4d17c286432bc03a03

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012-18 Bozhidar Batsov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1 @@
+# rubocop-performance

data/lib/rubocop-performance.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require_relative 'rubocop/performance/version'
+require_relative 'rubocop/cop/performance_cops'

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `caller[n]`
+      # can be replaced by `caller(n..n).first`.
+      #
+      # @example
+      #   # bad
+      #   caller[1]
+      #   caller.first
+      #   caller_locations[1]
+      #   caller_locations.first
+      #
+      #   # good
+      #   caller(2..2).first
+      #   caller(1..1).first
+      #   caller_locations(2..2).first
+      #   caller_locations(1..1).first
+      class Caller < Cop
+        MSG_BRACE = 'Use `%<method>s(%<n>d..%<n>d).first`' \
+                    ' instead of `%<method>s[%<m>d]`.'.freeze
+        MSG_FIRST = 'Use `%<method>s(%<n>d..%<n>d).first`' \
+                    ' instead of `%<method>s.first`.'.freeze
+
+        def_node_matcher :slow_caller?, <<-PATTERN
+          {
+            (send nil? {:caller :caller_locations})
+            (send nil? {:caller :caller_locations} int)
+          }
+        PATTERN
+
+        def_node_matcher :caller_with_scope_method?, <<-PATTERN
+          {
+            (send #slow_caller? :first)
+            (send #slow_caller? :[] int)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless caller_with_scope_method?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          method_name = node.receiver.method_name
+          caller_arg = node.receiver.first_argument
+          n = caller_arg ? int_value(caller_arg) : 1
+
+          if node.method_name == :[]
+            m = int_value(node.first_argument)
+            n += m
+            format(MSG_BRACE, n: n, m: m, method: method_name)
+          else
+            format(MSG_FIRST, n: n, method: method_name)
+          end
+        end
+
+        def int_value(node)
+          node.children[0]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # Place `when` conditions that use splat at the end
+      # of the list of `when` branches.
+      #
+      # Ruby has to allocate memory for the splat expansion every time
+      # that the `case` `when` statement is run. Since Ruby does not support
+      # fall through inside of `case` `when`, like some other languages do,
+      # the order of the `when` branches does not matter. By placing any
+      # splat expansions at the end of the list of `when` branches we will
+      # reduce the number of times that memory has to be allocated for
+      # the expansion.
+      #
+      # This is not a guaranteed performance improvement. If the data being
+      # processed by the `case` condition is normalized in a manner that favors
+      # hitting a condition in the splat expansion, it is possible that
+      # moving the splat condition to the end will use more memory,
+      # and run slightly slower.
+      #
+      # @example
+      #   # bad
+      #   case foo
+      #   when *condition
+      #     bar
+      #   when baz
+      #     foobar
+      #   end
+      #
+      #   case foo
+      #   when *[1, 2, 3, 4]
+      #     bar
+      #   when 5
+      #     baz
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when baz
+      #     foobar
+      #   when *condition
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when 1, 2, 3, 4
+      #     bar
+      #   when 5
+      #     baz
+      #   end
+      class CaseWhenSplat < Cop
+        include Alignment
+        include RangeHelp
+
+        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
+
+        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, location: range, message: message)
+          end
+        end
+
+        def autocorrect(when_node)
+          lambda do |corrector|
+            if needs_reorder?(when_node)
+              reorder_condition(corrector, when_node)
+            else
+              inline_fix_branch(corrector, when_node)
+            end
+          end
+        end
+
+        private
+
+        def replacement(conditions)
+          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)
+
+          corrector.replace(range, replacement(conditions))
+        end
+
+        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 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 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#{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 indent_for(node)
+          ' ' * node.loc.column
+        end
+
+        def splat_offenses(when_conditions)
+          found_non_splat = false
+
+          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 non_splat?(condition)
+          variable, = *condition
+
+          (condition.splat_type? && variable.array_type?) ||
+            !condition.splat_type?
+        end
+
+        def needs_reorder?(when_node)
+          following_branches =
+            when_node.parent.when_branches[(when_node.branch_index + 1)..-1]
+
+          following_branches.any? do |when_branch|
+            when_branch.conditions.any? do |condition|
+              non_splat?(condition)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# 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 `casecmp` instead of `%<methods>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 if part_of_ignored_node?(node)
+
+          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
+
+        def autocorrect(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
+          correction(node, receiver, method, arg, variable)
+        end
+
+        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 == :!=
+
+            # 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
+            replacement = if arg.send_type? || !parentheses?(arg)
+                            "#{variable.source}.casecmp(#{arg.source}).zero?"
+                          else
+                            "#{variable.source}.casecmp#{arg.source}.zero?"
+                          end
+
+            corrector.replace(node.loc.expression, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# 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