rubocop 0.51.0 → 0.87.0

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

@@ -1,93 +0,0 @@
-# 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 `%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))
-            end
-          end
-        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
-
-        # 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
-      end
-    end
-  end
-end

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

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

@@ -1,167 +0,0 @@
-# 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 = '%s[%s] = %s'.freeze
-        MSG = 'Use `%s` instead of `%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, assignments, 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.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, <<-PATTERN
-            (block (send _ :each_with_object _) (args _ $_) ...)
-          PATTERN
-        end
-      end
-    end
-  end
-end

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

@@ -1,223 +0,0 @@
-# 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.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 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, _, 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)
-          end
-        end
-
-        def message(node)
-          format(MSG, 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
-          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)
-          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/rubocop/cop/performance/reverse_each.rb

@@ -1,40 +0,0 @@
-# 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
-        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, location: range)
-          end
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.dot, UNDERSCORE) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of `count` on an
-      # `Array` and `Hash` and change them to `size`.
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3].count
-      #
-      #   # bad
-      #   {a: 1, b: 2, c: 3}.count
-      #
-      #   # good
-      #   [1, 2, 3].size
-      #
-      #   # good
-      #   {a: 1, b: 2, c: 3}.size
-      #
-      #   # good
-      #   [1, 2, 3].count { |e| e > 2 }
-      # TODO: Add advanced detection of variables that could
-      # have been assigned to an array or a hash.
-      class Size < Cop
-        MSG = 'Use `size` instead of `count`.'.freeze
-
-        def on_send(node)
-          return unless eligible_node?(node)
-
-          add_offense(node, location: :selector)
-        end
-
-        private
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'size') }
-        end
-
-        def eligible_node?(node)
-          return false unless node.method?(:count) && !node.arguments?
-
-          eligible_receiver?(node.receiver) && !allowed_parent?(node.parent)
-        end
-
-        def eligible_receiver?(node)
-          return false unless node
-
-          array?(node) || hash?(node)
-        end
-
-        def allowed_parent?(node)
-          node && node.block_type?
-        end
-
-        def array?(node)
-          _, constant = *node.receiver
-
-          node.array_type? || constant == :Array || node.method_name == :to_a
-        end
-
-        def hash?(node)
-          _, constant = *node.receiver
-
-          node.hash_type? || constant == :Hash || node.method_name == :to_h
-        end
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies unnecessary use of a regex where
-      # `String#start_with?` would suffice.
-      #
-      # @example
-      #   @bad
-      #   'abc' =~ /\Aab/
-      #   'abc'.match(/\Aab/)
-      #
-      #   @good
-      #   'abc'.start_with?('ab')
-      class StartWith < Cop
-        MSG = 'Use `String#start_with?` instead of a regex match anchored to ' \
-              'the beginning of the string.'.freeze
-        SINGLE_QUOTE = "'".freeze
-
-        def_node_matcher :redundant_regex?, <<-PATTERN
-          {(send $!nil? {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
-           (send (regexp (str $#literal_at_start?) (regopt)) {:match :=~} $_)}
-        PATTERN
-
-        def literal_at_start?(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 start of the string?
-          # (tricky: \s, \d, and so on are metacharacters, but other characters
-          #  escaped with a slash are just literals. LITERAL_REGEX takes all
-          #  that into account.)
-          regex_str =~ /\A\\A(?:#{LITERAL_REGEX})+\z/
-        end
-
-        def on_send(node)
-          return unless redundant_regex?(node)
-
-          add_offense(node)
-        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[2..-1] # drop \A anchor
-            regex_str = interpret_string_escapes(regex_str)
-
-            lambda do |corrector|
-              new_source = receiver.source + '.start_with?(' +
-                           to_string_literal(regex_str) + ')'
-              corrector.replace(node.source_range, new_source)
-            end
-          end
-        end
-      end
-    end
-  end
-end