rubbycop 0.49.0

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of `shuffle.first`, `shuffle.last`
+      # and `shuffle[]` and change them to use `sample` instead.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].shuffle.first
+      #   [1, 2, 3].shuffle.first(2)
+      #   [1, 2, 3].shuffle.last
+      #   [1, 2, 3].shuffle[2]
+      #   [1, 2, 3].shuffle[0, 2]    # sample(2) will do the same
+      #   [1, 2, 3].shuffle[0..2]    # sample(3) will do the same
+      #   [1, 2, 3].shuffle(random: Random.new).first
+      #
+      #   # good
+      #   [1, 2, 3].shuffle
+      #   [1, 2, 3].sample
+      #   [1, 2, 3].sample(3)
+      #   [1, 2, 3].shuffle[1, 3]    # sample(3) might return a longer Array
+      #   [1, 2, 3].shuffle[1..3]    # sample(3) might return a longer Array
+      #   [1, 2, 3].shuffle[foo, bar]
+      #   [1, 2, 3].shuffle(random: Random.new)
+      class Sample < Cop
+        MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'.freeze
+
+        def_node_matcher :sample_candidate?, <<-PATTERN
+          (send $(send _ :shuffle $...) ${:first :last :[]} $...)
+        PATTERN
+
+        def on_send(node)
+          sample_candidate?(node) do |shuffle, shuffle_arg, method, method_args|
+            return unless offensive?(method, method_args)
+
+            range = source_range(shuffle, node)
+            message = message(shuffle_arg, method, method_args, range)
+            add_offense(node, range, message)
+          end
+        end
+
+        def autocorrect(node)
+          shuffle_node, shuffle_arg, method, method_args =
+            sample_candidate?(node)
+
+          lambda do |corrector|
+            corrector.replace(source_range(shuffle_node, node),
+                              correction(shuffle_arg, method, method_args))
+          end
+        end
+
+        private
+
+        def offensive?(method, method_args)
+          case method
+          when :first, :last
+            true
+          when :[]
+            sample_size(method_args) != :unknown
+          else
+            false
+          end
+        end
+
+        def sample_size(method_args)
+          case method_args.size
+          when 1
+            sample_size_for_one_arg(method_args.first)
+          when 2
+            sample_size_for_two_args(*method_args)
+          end
+        end
+
+        def sample_size_for_one_arg(arg)
+          case arg.type
+          when :erange, :irange
+            range_size(arg)
+          when :int
+            arg.to_a.first.zero? ? nil : :unknown
+          else
+            :unknown
+          end
+        end
+
+        def sample_size_for_two_args(first, second)
+          return :unknown unless first.int_type? && first.to_a.first.zero?
+          second.int_type? ? second.to_a.first : :unknown
+        end
+
+        def range_size(range_node)
+          vals = range_node.to_a
+          return :unknown unless vals.all?(&:int_type?)
+          low, high = vals.map { |val| val.children[0] }
+          return :unknown unless low.zero? && high >= 0
+
+          case range_node.type
+          when :erange
+            (low...high).size
+          when :irange
+            (low..high).size
+          end
+        end
+
+        def source_range(shuffle_node, node)
+          Parser::Source::Range.new(shuffle_node.source_range.source_buffer,
+                                    shuffle_node.loc.selector.begin_pos,
+                                    node.source_range.end_pos)
+        end
+
+        def message(shuffle_arg, method, method_args, range)
+          format(MSG,
+                 correct: correction(shuffle_arg, method, method_args),
+                 incorrect: range.source)
+        end
+
+        def correction(shuffle_arg, method, method_args)
+          shuffle_arg = extract_source(shuffle_arg)
+          sample_arg = sample_arg(method, method_args)
+          args = [sample_arg, shuffle_arg].compact.join(', ')
+          args.empty? ? 'sample' : "sample(#{args})"
+        end
+
+        def sample_arg(method, method_args)
+          case method
+          when :first, :last
+            extract_source(method_args)
+          when :[]
+            sample_size(method_args)
+          end
+        end
+
+        def extract_source(args)
+          args.empty? ? nil : args.first.source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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, node.loc.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/rubbycop/cop/performance/start_with.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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?, <<-END
+          {(send $!nil {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
+           (send (regexp (str $#literal_at_start?) (regopt)) {:match :=~} $_)}
+        END
+
+        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, :expression)
+        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/rubbycop/cop/performance/string_replacement.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+        MSG = 'Use `%s` instead of `%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, range(node), 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, replacement_method, 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/rubbycop/cop/performance/times_map.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+        MSG = 'Use `Array.new` with a block instead of `.times.%s`.'.freeze
+
+        def on_send(node)
+          check(node)
+        end
+
+        def on_block(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          times_map_call(node) do |map_or_collect|
+            add_offense(node, :expression, format(MSG, map_or_collect))
+          end
+        end
+
+        def_node_matcher :times_map_call, <<-END
+          {(block (send (send !nil :times) ${:map :collect}) ...)
+           (send (send !nil :times) ${:map :collect} (block_pass ...))}
+        END
+
+        def autocorrect(node)
+          send_node = node.send_type? ? node : node.each_descendant(:send).first
+
+          count, = *send_node.receiver
+
+          replacement =
+            "Array.new(#{count.source}" \
+            "#{send_node.arguments.map { |arg| ", #{arg.source}" }.join})"
+
+          lambda do |corrector|
+            corrector.replace(send_node.loc.expression, replacement)
+          end
+        end
+      end
+    end
+  end
+end