rubocop 0.67.2 → 0.68.0

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

@@ -1,42 +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
-        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/size.rb

@@ -1,77 +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
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'size') }
-        end
-
-        private
-
-        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)
-          return true if node.array_type?
-          return false unless node.send_type?
-
-          _, constant = *node.receiver
-
-          constant == :Array || node.method_name == :to_a
-        end
-
-        def hash?(node)
-          return true if node.hash_type?
-          return false unless node.send_type?
-
-          _, constant = *node.receiver
-
-          constant == :Hash || node.method_name == :to_h
-        end
-      end
-    end
-  end
-end

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

@@ -1,59 +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'.match?(/\Aab/)
-      #   '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 :=~ :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

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

@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where `gsub` can be replaced by
-      # `tr` or `delete`.
-      #
-      # @example
-      #   # bad
-      #   'abc'.gsub('b', 'd')
-      #   'abc'.gsub('a', '')
-      #   'abc'.gsub(/a/, 'd')
-      #   'abc'.gsub!('a', 'd')
-      #
-      #   # good
-      #   'abc'.gsub(/.*/, 'a')
-      #   'abc'.gsub(/a+/, 'd')
-      #   'abc'.tr('b', 'd')
-      #   'a b c'.delete(' ')
-      class StringReplacement < Cop
-        include RangeHelp
-
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
-        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
-        DELETE = 'delete'.freeze
-        TR = 'tr'.freeze
-        BANG = '!'.freeze
-        SINGLE_QUOTE = "'".freeze
-
-        def_node_matcher :string_replacement?, <<-PATTERN
-          (send _ {:gsub :gsub!}
-                    ${regexp str (send (const nil? :Regexp) {:new :compile} _)}
-                    $str)
-        PATTERN
-
-        def on_send(node)
-          string_replacement?(node) do |first_param, second_param|
-            return if accept_second_param?(second_param)
-            return if accept_first_param?(first_param)
-
-            offense(node, first_param, second_param)
-          end
-        end
-
-        def autocorrect(node)
-          _string, _method, first_param, second_param = *node
-          first_source, = first_source(first_param)
-          second_source, = *second_param
-
-          unless first_param.str_type?
-            first_source = interpret_string_escapes(first_source)
-          end
-
-          replacement_method =
-            replacement_method(node, first_source, second_source)
-
-          replace_method(node, first_source, second_source, first_param,
-                         replacement_method)
-        end
-
-        def replace_method(node, first, second, first_param, replacement)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, replacement)
-            unless first_param.str_type?
-              corrector.replace(first_param.source_range,
-                                to_string_literal(first))
-            end
-
-            if second.empty? && first.length == 1
-              remove_second_param(corrector, node, first_param)
-            end
-          end
-        end
-
-        private
-
-        def accept_second_param?(second_param)
-          second_source, = *second_param
-          second_source.length > 1
-        end
-
-        def accept_first_param?(first_param)
-          first_source, options = first_source(first_param)
-          return true if first_source.nil?
-
-          unless first_param.str_type?
-            return true if options
-            return true unless first_source =~ DETERMINISTIC_REGEX
-
-            # This must be done after checking DETERMINISTIC_REGEX
-            # Otherwise things like \s will trip us up
-            first_source = interpret_string_escapes(first_source)
-          end
-
-          first_source.length != 1
-        end
-
-        def offense(node, first_param, second_param)
-          first_source, = first_source(first_param)
-          unless first_param.str_type?
-            first_source = interpret_string_escapes(first_source)
-          end
-          second_source, = *second_param
-          message = message(node, first_source, second_source)
-
-          add_offense(node, location: range(node), message: message)
-        end
-
-        def first_source(first_param)
-          case first_param.type
-          when :regexp
-            source_from_regex_literal(first_param)
-          when :send
-            source_from_regex_constructor(first_param)
-          when :str
-            first_param.children.first
-          end
-        end
-
-        def source_from_regex_literal(node)
-          regex, options = *node
-          source, = *regex
-          options, = *options
-          [source, options]
-        end
-
-        def source_from_regex_constructor(node)
-          _const, _init, regex = *node
-          case regex.type
-          when :regexp
-            source_from_regex_literal(regex)
-          when :str
-            source, = *regex
-            source
-          end
-        end
-
-        def range(node)
-          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
-        end
-
-        def replacement_method(node, first_source, second_source)
-          replacement = if second_source.empty? && first_source.length == 1
-                          DELETE
-                        else
-                          TR
-                        end
-
-          "#{replacement}#{BANG if node.bang_method?}"
-        end
-
-        def message(node, first_source, second_source)
-          replacement_method =
-            replacement_method(node, first_source, second_source)
-
-          format(MSG, prefer: replacement_method, current: node.method_name)
-        end
-
-        def method_suffix(node)
-          node.loc.end ? node.loc.end.source : ''
-        end
-
-        def remove_second_param(corrector, node, first_param)
-          end_range = range_between(first_param.source_range.end_pos,
-                                    node.source_range.end_pos)
-
-          corrector.replace(end_range, method_suffix(node))
-        end
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop checks for .times.map calls.
-      # In most cases such calls can be replaced
-      # with an explicit array creation.
-      #
-      # @example
-      #   # bad
-      #   9.times.map do |i|
-      #     i.to_s
-      #   end
-      #
-      #   # good
-      #   Array.new(9) do |i|
-      #     i.to_s
-      #   end
-      class TimesMap < Cop
-        MESSAGE = 'Use `Array.new(%<count>s)` with a block ' \
-                  'instead of `.times.%<map_or_collect>s`'.freeze
-        MESSAGE_ONLY_IF = 'only if `%<count>s` is always 0 or more'.freeze
-
-        def on_send(node)
-          check(node)
-        end
-
-        def on_block(node)
-          check(node)
-        end
-
-        def autocorrect(node)
-          map_or_collect, count = times_map_call(node)
-
-          replacement =
-            "Array.new(#{count.source}" \
-            "#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
-
-          lambda do |corrector|
-            corrector.replace(map_or_collect.loc.expression, replacement)
-          end
-        end
-
-        private
-
-        def check(node)
-          times_map_call(node) do |map_or_collect, count|
-            add_offense(node, message: message(map_or_collect, count))
-          end
-        end
-
-        def message(map_or_collect, count)
-          template = if count.literal?
-                       MESSAGE + '.'
-                     else
-                       "#{MESSAGE} #{MESSAGE_ONLY_IF}."
-                     end
-          format(template,
-                 count: count.source,
-                 map_or_collect: map_or_collect.method_name)
-        end
-
-        def_node_matcher :times_map_call, <<-PATTERN
-          {(block $(send (send $!nil? :times) {:map :collect}) ...)
-           $(send (send $!nil? :times) {:map :collect} (block_pass ...))}
-        PATTERN
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # In Ruby 2.3 or later, use unary plus operator to unfreeze a string
-      # literal instead of `String#dup` and `String.new`.
-      # Unary plus operator is faster than `String#dup`.
-      #
-      # Note: `String.new` (without operator) is not exactly the same as `+''`.
-      # These differ in encoding. `String.new.encoding` is always `ASCII-8BIT`.
-      # However, `(+'').encoding` is the same as script encoding(e.g. `UTF-8`).
-      # So, if you expect `ASCII-8BIT` encoding, disable this cop.
-      #
-      # @example
-      #   # bad
-      #   ''.dup
-      #   "something".dup
-      #   String.new
-      #   String.new('')
-      #   String.new('something')
-      #
-      #   # good
-      #   +'something'
-      #   +''
-      class UnfreezeString < Cop
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.3
-
-        MSG = 'Use unary plus to get an unfrozen string literal.'.freeze
-
-        def_node_matcher :dup_string?, <<-PATTERN
-          (send {str dstr} :dup)
-        PATTERN
-
-        def_node_matcher :string_new?, <<-PATTERN
-          {
-            (send (const nil? :String) :new {str dstr})
-            (send (const nil? :String) :new)
-          }
-        PATTERN
-
-        def on_send(node)
-          add_offense(node) if dup_string?(node) || string_new?(node)
-        end
-      end
-    end
-  end
-end