rubbycop 0.49.0

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 = '%s[%s] = %s'.freeze
+        MSG = 'Use `%s` instead of `%s`.'.freeze
+
+        def_node_matcher :redundant_merge, '(send $_ :merge! (hash $...))'
+        def_node_matcher :modifier_flow_control?, <<-END
+          [{if while until} modifier_form?]
+        END
+
+        def on_send(node)
+          each_redundant_merge(node) do |receiver, pairs|
+            assignments = to_assignments(receiver, pairs).join('; ')
+            message = format(MSG, assignments, node.source)
+            add_offense(node, :expression, message)
+          end
+        end
+
+        def autocorrect(node)
+          redundant_merge(node) do |receiver, pairs|
+            new_source = to_assignments(receiver, pairs).join("\n")
+
+            parent = node.parent
+            if parent && pairs.size > 1
+              correct_multiple_elements(node, parent, new_source)
+            else
+              correct_single_element(node, new_source)
+            end
+          end
+        end
+
+        private
+
+        def each_redundant_merge(node)
+          redundant_merge(node) do |receiver, pairs|
+            next unless receiver
+            next if node.value_used? &&
+                    !EachWithObjectInspector.new(node, receiver).value_used?
+            next if pairs.size > 1 && !receiver.pure?
+            next if pairs.size > max_key_value_pairs
+
+            yield receiver, pairs
+          end
+        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.source, key, 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
+          cop_config['MaxKeyValuePairs'].to_i
+        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, <<-END
+            (block (send _ :each_with_object _) (args _ $_) ...)
+          END
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+        MSG = 'Use `sort` instead of `sort_by { |%s| %s }`.'.freeze
+
+        def_node_matcher :redundant_sort_by, <<-END
+          (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
+        END
+
+        def on_block(node)
+          redundant_sort_by(node) do |send, var_name|
+            range = sort_by_range(send, node)
+            add_offense(node, range, format(MSG, var_name, 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/rubbycop/cop/performance/regexp_match.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.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 =~ /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
+
+        MSG =
+          'Use `match?` instead of `%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_node_matcher :match_with_lvasgn?, <<-PATTERN
+          (match_with_lvasgn !nil !nil)
+        PATTERN
+
+        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, _, arg = *node
+              correct_operator(corrector, recv, arg)
+            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, :expression,
+                        format(MSG, cond.loc.selector.source))
+          end
+        end
+
+        def last_match_used?(match_node)
+          scope_root = scope_root(match_node)
+          body = scope_root ? scope_body(scope_root) : match_node.ancestors.last
+          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]
+          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)
+          buffer = processed_source.buffer
+          op_begin_pos = recv.loc.expression.end_pos
+          op_end_pos = arg.loc.expression.begin_pos
+          op_range = Parser::Source::Range.new(buffer, op_begin_pos, op_end_pos)
+          corrector.replace(op_range, '.match?(')
+          corrector.insert_after(arg.loc.expression, ')')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+        MSG = 'Use `reverse_each` instead of `reverse.each`.'.freeze
+        UNDERSCORE = '_'.freeze
+
+        def_node_matcher :reverse_each?, <<-MATCHER
+          (send $(send array :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, range)
+          end
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.dot, UNDERSCORE) }
+        end
+      end
+    end
+  end
+end