rubocop-performance 0.0.0

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

@@ -0,0 +1,78 @@
+# 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
+        include RangeHelp
+
+        MSG = 'Use `flat_map` instead of `%<method>s...%<flatten>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, method: first_method,
+                                               flatten: flatten))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop checks for inefficient searching of keys and values within
+      # hashes.
+      #
+      # `Hash#keys.include?` is less efficient than `Hash#key?` because
+      # the former allocates a new array and then performs an O(n) search
+      # through that array, while `Hash#key?` does not allocate any array and
+      # performs a faster O(1) search for the key.
+      #
+      # `Hash#values.include?` is less efficient than `Hash#value?`. While they
+      # both perform an O(n) search through all of the values, calling `values`
+      # allocates a new array while using `value?` does not.
+      #
+      # @example
+      #   # bad
+      #   { a: 1, b: 2 }.keys.include?(:a)
+      #   { a: 1, b: 2 }.keys.include?(:z)
+      #   h = { a: 1, b: 2 }; h.keys.include?(100)
+      #
+      #   # good
+      #   { a: 1, b: 2 }.key?(:a)
+      #   { a: 1, b: 2 }.has_key?(:z)
+      #   h = { a: 1, b: 2 }; h.key?(100)
+      #
+      #   # bad
+      #   { a: 1, b: 2 }.values.include?(2)
+      #   { a: 1, b: 2 }.values.include?('garbage')
+      #   h = { a: 1, b: 2 }; h.values.include?(nil)
+      #
+      #   # good
+      #   { a: 1, b: 2 }.value?(2)
+      #   { a: 1, b: 2 }.has_value?('garbage')
+      #   h = { a: 1, b: 2 }; h.value?(nil)
+      #
+      class InefficientHashSearch < Cop
+        def_node_matcher :inefficient_include?, <<-PATTERN
+          (send (send $_ {:keys :values}) :include? _)
+        PATTERN
+
+        def on_send(node)
+          inefficient_include?(node) do |receiver|
+            return if receiver.nil?
+
+            add_offense(node)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            # Replace `keys.include?` or `values.include?` with the appropriate
+            # `key?`/`value?` method.
+            corrector.replace(
+              node.loc.expression,
+              "#{autocorrect_hash_expression(node)}."\
+              "#{autocorrect_method(node)}(#{autocorrect_argument(node)})"
+            )
+          end
+        end
+
+        private
+
+        def message(node)
+          "Use `##{autocorrect_method(node)}` instead of "\
+            "`##{current_method(node)}.include?`."
+        end
+
+        def autocorrect_method(node)
+          case current_method(node)
+          when :keys then use_long_method ? 'has_key?' : 'key?'
+          when :values then use_long_method ? 'has_value?' : 'value?'
+          end
+        end
+
+        def current_method(node)
+          node.receiver.method_name
+        end
+
+        def use_long_method
+          preferred_config = config.for_all_cops['Style/PreferredHashMethods']
+          preferred_config &&
+            preferred_config['EnforcedStyle'] == 'long' &&
+            preferred_config['Enabled']
+        end
+
+        def autocorrect_argument(node)
+          node.arguments.first.source
+        end
+
+        def autocorrect_hash_expression(node)
+          node.receiver.receiver.source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `lstrip.rstrip` can be replaced by
+      # `strip`.
+      #
+      # @example
+      #   # bad
+      #   'abc'.lstrip.rstrip
+      #   'abc'.rstrip.lstrip
+      #
+      #   # good
+      #   'abc'.strip
+      class LstripRstrip < Cop
+        include RangeHelp
+
+        MSG = 'Use `strip` instead of `%<methods>s`.'.freeze
+
+        def_node_matcher :lstrip_rstrip, <<-PATTERN
+          {(send $(send _ $:rstrip) $:lstrip)
+           (send $(send _ $:lstrip) $:rstrip)}
+        PATTERN
+
+        def on_send(node)
+          lstrip_rstrip(node) do |first_send, method_one, method_two|
+            range = range_between(first_send.loc.selector.begin_pos,
+                                  node.source_range.end_pos)
+            add_offense(node,
+                        location: range,
+                        message: format(MSG,
+                                        methods: "#{method_one}.#{method_two}"))
+          end
+        end
+
+        def autocorrect(node)
+          range = range_between(node.receiver.loc.selector.begin_pos,
+                                node.source_range.end_pos)
+
+          ->(corrector) { corrector.replace(range, 'strip') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# 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.
+      #
+      # @example
+      #   # bad
+      #   ('a'..'z').include?('b') # => true
+      #
+      #   # good
+      #   ('a'..'z').cover?('b') # => true
+      #
+      #   # 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

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies the use of a `&block` parameter and `block.call`
+      # where `yield` would do just as well.
+      #
+      # @example
+      #   # bad
+      #   def method(&block)
+      #     block.call
+      #   end
+      #   def another(&func)
+      #     func.call 1, 2, 3
+      #   end
+      #
+      #   # good
+      #   def method
+      #     yield
+      #   end
+      #   def another
+      #     yield 1, 2, 3
+      #   end
+      class RedundantBlockCall < Cop
+        MSG = 'Use `yield` instead of `%<argname>s.call`.'.freeze
+        YIELD = 'yield'.freeze
+        OPEN_PAREN = '('.freeze
+        CLOSE_PAREN = ')'.freeze
+        SPACE = ' '.freeze
+
+        def_node_matcher :blockarg_def, <<-PATTERN
+          {(def  _   (args ... (blockarg $_)) $_)
+           (defs _ _ (args ... (blockarg $_)) $_)}
+        PATTERN
+
+        def_node_search :blockarg_calls, <<-PATTERN
+          (send (lvar %1) :call ...)
+        PATTERN
+
+        def_node_search :blockarg_assigned?, <<-PATTERN
+          (lvasgn %1 ...)
+        PATTERN
+
+        def on_def(node)
+          blockarg_def(node) do |argname, body|
+            next unless body
+
+            calls_to_report(argname, body).each do |blockcall|
+              add_offense(blockcall, message: format(MSG, argname: argname))
+            end
+          end
+        end
+
+        # offenses are registered on the `block.call` nodes
+        def autocorrect(node)
+          _receiver, _method, *args = *node
+          new_source = String.new(YIELD)
+          unless args.empty?
+            new_source += if parentheses?(node)
+                            OPEN_PAREN
+                          else
+                            SPACE
+                          end
+
+            new_source << args.map(&:source).join(', ')
+          end
+
+          new_source << CLOSE_PAREN if parentheses?(node) && !args.empty?
+          ->(corrector) { corrector.replace(node.source_range, new_source) }
+        end
+
+        private
+
+        def calls_to_report(argname, body)
+          return [] if blockarg_assigned?(body, argname)
+
+          calls = to_enum(:blockarg_calls, body, argname)
+
+          return [] if calls.any? { |call| args_include_block_pass?(call) }
+
+          calls
+        end
+
+        def args_include_block_pass?(blockcall)
+          _receiver, _call, *args = *blockcall
+
+          args.any?(&:block_pass_type?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies the use of `Regexp#match` or `String#match`, which
+      # returns `#<MatchData>`/`nil`. The return value of `=~` is an integral
+      # index/`nil` and is more performant.
+      #
+      # @example
+      #   # bad
+      #   do_something if str.match(/regex/)
+      #   while regex.match('str')
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   method(str =~ /regex/)
+      #   return value unless regex =~ 'str'
+      class RedundantMatch < Cop
+        MSG = 'Use `=~` in places where the `MatchData` returned by ' \
+              '`#match` will not be used.'.freeze
+
+        # 'match' is a fairly generic name, so we don't flag it unless we see
+        # a string or regexp literal on one side or the other
+        def_node_matcher :match_call?, <<-PATTERN
+          {(send {str regexp} :match _)
+           (send !nil? :match {str regexp})}
+        PATTERN
+
+        def_node_matcher :only_truthiness_matters?, <<-PATTERN
+          ^({if while until case while_post until_post} equal?(%0) ...)
+        PATTERN
+
+        def on_send(node)
+          return unless match_call?(node) &&
+                        (!node.value_used? || only_truthiness_matters?(node)) &&
+                        !(node.parent && node.parent.block_type?)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          # Regexp#match can take a second argument, but this cop doesn't
+          # register an offense in that case
+          return unless node.first_argument.regexp_type?
+
+          new_source =
+            node.receiver.source + ' =~ ' + node.first_argument.source
+
+          ->(corrector) { corrector.replace(node.source_range, new_source) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `Hash#merge!` can be replaced by
+      # `Hash#[]=`.
+      #
+      # @example
+      #   hash.merge!(a: 1)
+      #   hash.merge!({'key' => 'value'})
+      #   hash.merge!(a: 1, b: 2)
+      class RedundantMerge < Cop
+        AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
+
+        def_node_matcher :redundant_merge_candidate, <<-PATTERN
+          (send $!nil? :merge! [(hash $...) !kwsplat_type?])
+        PATTERN
+
+        def_node_matcher :modifier_flow_control?, <<-PATTERN
+          [{if while until} modifier_form?]
+        PATTERN
+
+        def on_send(node)
+          each_redundant_merge(node) do |redundant_merge_node|
+            add_offense(redundant_merge_node)
+          end
+        end
+
+        def autocorrect(node)
+          redundant_merge_candidate(node) do |receiver, pairs|
+            new_source = to_assignments(receiver, pairs).join("\n")
+
+            if node.parent && pairs.size > 1
+              correct_multiple_elements(node, node.parent, new_source)
+            else
+              correct_single_element(node, new_source)
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          redundant_merge_candidate(node) do |receiver, pairs|
+            assignments = to_assignments(receiver, pairs).join('; ')
+
+            format(MSG, prefer: assignments, current: node.source)
+          end
+        end
+
+        def each_redundant_merge(node)
+          redundant_merge_candidate(node) do |receiver, pairs|
+            next if non_redundant_merge?(node, receiver, pairs)
+
+            yield node
+          end
+        end
+
+        def non_redundant_merge?(node, receiver, pairs)
+          non_redundant_pairs?(receiver, pairs) ||
+            non_redundant_value_used?(receiver, node)
+        end
+
+        def non_redundant_pairs?(receiver, pairs)
+          pairs.size > 1 && !receiver.pure? || pairs.size > max_key_value_pairs
+        end
+
+        def non_redundant_value_used?(receiver, node)
+          node.value_used? &&
+            !EachWithObjectInspector.new(node, receiver).value_used?
+        end
+
+        def correct_multiple_elements(node, parent, new_source)
+          if modifier_flow_control?(parent)
+            new_source = rewrite_with_modifier(node, parent, new_source)
+            node = parent
+          else
+            padding = "\n#{leading_spaces(node)}"
+            new_source.gsub!(/\n/, padding)
+          end
+
+          ->(corrector) { corrector.replace(node.source_range, new_source) }
+        end
+
+        def correct_single_element(node, new_source)
+          ->(corrector) { corrector.replace(node.source_range, new_source) }
+        end
+
+        def to_assignments(receiver, pairs)
+          pairs.map do |pair|
+            key, value = *pair
+
+            key = key.sym_type? && pair.colon? ? ":#{key.source}" : key.source
+
+            format(AREF_ASGN, receiver: receiver.source,
+                              key: key,
+                              value: value.source)
+          end
+        end
+
+        def rewrite_with_modifier(node, parent, new_source)
+          cond, = *parent
+          padding = "\n#{(' ' * indent_width) + leading_spaces(node)}"
+          new_source.gsub!(/\n/, padding)
+
+          parent.loc.keyword.source << ' ' << cond.source << padding <<
+            new_source << "\n" << leading_spaces(node) << 'end'
+        end
+
+        def leading_spaces(node)
+          node.source_range.source_line[/\A\s*/]
+        end
+
+        def indent_width
+          @config.for_cop('IndentationWidth')['Width'] || 2
+        end
+
+        def max_key_value_pairs
+          Integer(cop_config['MaxKeyValuePairs'])
+        end
+
+        # A utility class for checking the use of values within an
+        # `each_with_object` call.
+        class EachWithObjectInspector
+          extend NodePattern::Macros
+
+          def initialize(node, receiver)
+            @node = node
+            @receiver = unwind(receiver)
+          end
+
+          def value_used?
+            return false unless eligible_receiver? && second_argument
+
+            receiver.loc.name.source == second_argument.loc.name.source
+          end
+
+          private
+
+          attr_reader :node, :receiver
+
+          def eligible_receiver?
+            receiver.respond_to?(:lvar_type?) && receiver.lvar_type?
+          end
+
+          def second_argument
+            parent = node.parent
+            parent = parent.parent if parent.begin_type?
+
+            @second_argument ||= each_with_object_node(parent)
+          end
+
+          def unwind(receiver)
+            while receiver.respond_to?(:send_type?) && receiver.send_type?
+              receiver, = *receiver
+            end
+            receiver
+          end
+
+          def_node_matcher :each_with_object_node, <<-PATTERN
+            (block (send _ :each_with_object _) (args _ $_) ...)
+          PATTERN
+        end
+      end
+    end
+  end
+end