rubocop-performance 0.0.0

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

@@ -0,0 +1,71 @@
+# 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)
+          _, 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

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

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

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

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

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify instances of sorting and then
+      # taking only the first or last element. The same behavior can
+      # be accomplished without a relatively expensive sort by using
+      # `Enumerable#min` instead of sorting and taking the first
+      # element and `Enumerable#max` instead of sorting and taking the
+      # last element. Similarly, `Enumerable#min_by` and
+      # `Enumerable#max_by` can replace `Enumerable#sort_by` calls
+      # after which only the first or last element is used.
+      #
+      # @example
+      #   # bad
+      #   [2, 1, 3].sort.first
+      #   [2, 1, 3].sort[0]
+      #   [2, 1, 3].sort.at(0)
+      #   [2, 1, 3].sort.slice(0)
+      #
+      #   # good
+      #   [2, 1, 3].min
+      #
+      #   # bad
+      #   [2, 1, 3].sort.last
+      #   [2, 1, 3].sort[-1]
+      #   [2, 1, 3].sort.at(-1)
+      #   [2, 1, 3].sort.slice(-1)
+      #
+      #   # good
+      #   [2, 1, 3].max
+      #
+      #   # bad
+      #   arr.sort_by(&:foo).first
+      #   arr.sort_by(&:foo)[0]
+      #   arr.sort_by(&:foo).at(0)
+      #   arr.sort_by(&:foo).slice(0)
+      #
+      #   # good
+      #   arr.min_by(&:foo)
+      #
+      #   # bad
+      #   arr.sort_by(&:foo).last
+      #   arr.sort_by(&:foo)[-1]
+      #   arr.sort_by(&:foo).at(-1)
+      #   arr.sort_by(&:foo).slice(-1)
+      #
+      #   # good
+      #   arr.max_by(&:foo)
+      #
+      class UnneededSort < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<suggestion>s` instead of '\
+              '`%<sorter>s...%<accessor_source>s`.'.freeze
+
+        def_node_matcher :unneeded_sort?, <<-MATCHER
+          {
+            (send $(send _ $:sort ...) ${:last :first})
+            (send $(send _ $:sort ...) ${:[] :at :slice} {(int 0) (int -1)})
+
+            (send $(send _ $:sort_by _) ${:last :first})
+            (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
+
+            (send (block $(send _ ${:sort_by :sort}) ...) ${:last :first})
+            (send
+              (block $(send _ ${:sort_by :sort}) ...)
+              ${:[] :at :slice} {(int 0) (int -1)}
+            )
+          }
+        MATCHER
+
+        def on_send(node)
+          unneeded_sort?(node) do |sort_node, sorter, accessor|
+            range = range_between(
+              sort_node.loc.selector.begin_pos,
+              node.loc.expression.end_pos
+            )
+
+            add_offense(node,
+                        location: range,
+                        message: message(node,
+                                         sorter,
+                                         accessor))
+          end
+        end
+
+        def autocorrect(node)
+          sort_node, sorter, accessor = unneeded_sort?(node)
+
+          lambda do |corrector|
+            # Remove accessor, e.g. `first` or `[-1]`.
+            corrector.remove(
+              range_between(
+                accessor_start(node),
+                node.loc.expression.end_pos
+              )
+            )
+
+            # Replace "sort" or "sort_by" with the appropriate min/max method.
+            corrector.replace(
+              sort_node.loc.selector,
+              suggestion(sorter, accessor, arg_value(node))
+            )
+          end
+        end
+
+        private
+
+        def message(node, sorter, accessor)
+          accessor_source = range_between(
+            node.loc.selector.begin_pos,
+            node.loc.expression.end_pos
+          ).source
+
+          format(MSG,
+                 suggestion: suggestion(sorter,
+                                        accessor,
+                                        arg_value(node)),
+                 sorter: sorter,
+                 accessor_source: accessor_source)
+        end
+
+        def suggestion(sorter, accessor, arg)
+          base(accessor, arg) + suffix(sorter)
+        end
+
+        def base(accessor, arg)
+          if accessor == :first || (arg && arg.zero?)
+            'min'
+          elsif accessor == :last || arg == -1
+            'max'
+          end
+        end
+
+        def suffix(sorter)
+          if sorter == :sort
+            ''
+          elsif sorter == :sort_by
+            '_by'
+          end
+        end
+
+        def arg_node(node)
+          node.arguments.first
+        end
+
+        def arg_value(node)
+          arg_node(node).nil? ? nil : arg_node(node).node_parts.first
+        end
+
+        # This gets the start of the accessor whether it has a dot
+        # (e.g. `.first`) or doesn't (e.g. `[0]`)
+        def accessor_start(node)
+          if node.loc.dot
+            node.loc.dot.begin_pos
+          else
+            node.loc.selector.begin_pos
+          end
+        end
+      end
+    end
+  end
+end