rubocop 0.31.0 → 0.35.0

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

@@ -14,12 +14,15 @@ module RuboCop
       #   [1, 2, 3].reject { |e| e > 2 }.length
       #   [1, 2, 3].select { |e| e > 2 }.count { |e| e.odd? }
       #   [1, 2, 3].reject { |e| e > 2 }.count { |e| e.even? }
+      #   array.select(&:value).count
       #
       #   # good
       #   [1, 2, 3].count { |e| e > 2 }
       #   [1, 2, 3].count { |e| e < 2 }
       #   [1, 2, 3].count { |e| e > 2 && e.odd? }
       #   [1, 2, 3].count { |e| e < 2 && e.even? }
+      #   Model.select('field AS field_one').count
+      #   Model.select(:value).count
       class Count < Cop
         MSG = 'Use `count` instead of `%s...%s`.'
 
@@ -27,56 +30,58 @@ module RuboCop
         COUNTERS = [:count, :length, :size]
 
         def on_send(node)
-          expression, first_method, second_method, third_method = parse(node)
-
-          return unless COUNTERS.include?(third_method)
-
-          begin_pos = if SELECTORS.include?(first_method)
-                        return if second_method.is_a?(Symbol)
-                        expression.loc.selector.begin_pos
-                      else
-                        return unless SELECTORS.include?(second_method)
-                        expression.parent.loc.selector.begin_pos
-                      end
-
+          selector, selector_loc, params, counter = parse(node)
+          return unless COUNTERS.include?(counter)
+          return unless SELECTORS.include?(selector)
+          return if params && !params.block_pass_type?
           return if node.parent && node.parent.block_type?
 
           range = Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                            begin_pos,
+                                            selector_loc.begin_pos,
                                             node.loc.expression.end_pos)
 
-          add_offense(node, range,
-                      format(MSG, first_method || second_method, third_method))
+          add_offense(node, range, format(MSG, selector, counter))
         end
 
         def autocorrect(node)
-          expression, first_method, second_method, = parse(node)
+          selector, selector_loc = parse(node)
 
-          return if first_method == :reject || second_method == :reject
+          return if selector == :reject
 
-          selector = if SELECTORS.include?(first_method)
-                       expression.loc.selector
-                     else
-                       expression.parent.loc.selector
-                     end
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                            node.loc.dot.begin_pos,
+                                            node.loc.expression.end_pos)
 
           lambda do |corrector|
-            range = Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                              node.loc.dot.begin_pos,
-                                              node.loc.expression.end_pos)
             corrector.remove(range)
-            corrector.replace(selector, 'count')
+            corrector.replace(selector_loc, 'count')
           end
         end
 
         private
 
         def parse(node)
-          left, third_method = *node
-          expression, second_method = *left
-          _enumerable, first_method = *expression
+          left, counter = *node
+          expression, selector, params = *left
+
+          selector_loc =
+            if selector.is_a?(Symbol)
+              if expression && expression.parent.loc.respond_to?(:selector)
+                expression.parent.loc.selector
+              else
+                left.loc.selector if left.loc.respond_to?(:selector)
+              end
+            else
+              _enumerable, selector, params = *expression
+
+              expression.loc.selector if contains_selector?(expression)
+            end
+
+          [selector, selector_loc, params, counter]
+        end
 
-          [expression, first_method, second_method, third_method]
+        def contains_selector?(node)
+          node.respond_to?(:loc) && node.loc.respond_to?(:selector)
         end
       end
     end

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

@@ -22,21 +22,24 @@ module RuboCop
         REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%s`.'
 
         SELECT_METHODS = [:select, :find_all]
+        DANGEROUS_METHODS = [:first, :last]
 
         def on_send(node)
           receiver, second_method = *node
-          return unless second_method == :first || second_method == :last
           return if receiver.nil?
+          return unless DANGEROUS_METHODS.include?(second_method)
 
           receiver, _args, body = *receiver if receiver.block_type?
 
-          _, first_method, args = *receiver
+          caller, first_method, args = *receiver
 
           # check that we have usual block or block pass
           return if body.nil? && (args.nil? || !args.block_pass_type?)
 
           return unless SELECT_METHODS.include?(first_method)
 
+          return if lazy?(caller)
+
           range = receiver.loc.selector.join(node.loc.selector)
 
           message = second_method == :last ? REVERSE_MSG : MSG
@@ -54,7 +57,11 @@ module RuboCop
                         else
                           preferred_method
                         end
-          first_range = node.loc.dot.join(node.loc.selector)
+
+          first_range = Parser::Source::Range.new(
+            receiver.loc.expression.source,
+            receiver.loc.end.end_pos,
+            receiver.loc.end.end_pos).join(node.loc.selector)
 
           receiver, _args, _body = *receiver if receiver.block_type?
 
@@ -70,6 +77,12 @@ module RuboCop
           config.for_cop('Style/CollectionMethods') \
             ['PreferredMethods']['detect'] || 'detect'
         end
+
+        def lazy?(node)
+          return false if node.nil?
+          receiver, method, _args = *node
+          method == :lazy && !receiver.nil?
+        end
       end
     end
   end

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

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # Do not compute the size of statically sized objects.
+      class FixedSize < Cop
+        MSG = 'Do not compute the size of statically sized objects.'.freeze
+        COUNTERS = [:count, :length, :size].freeze
+        STATIC_SIZED_TYPES = [:array, :hash, :str, :sym].freeze
+
+        def on_send(node)
+          variable, method, arg = *node
+          return unless variable
+          return unless COUNTERS.include?(method)
+          return unless STATIC_SIZED_TYPES.include?(variable.type)
+          return if contains_splat?(variable)
+          return if contains_double_splat?(variable)
+          return if string_argument?(arg)
+          if node.parent
+            return if node.parent.casgn_type? || node.parent.block_type?
+          end
+          add_offense(node, :expression)
+        end
+
+        private
+
+        def contains_splat?(node)
+          return unless node.array_type?
+
+          node.children.any? do |child|
+            child.respond_to?(:splat_type?) && child.splat_type?
+          end
+        end
+
+        def contains_double_splat?(node)
+          return unless node.hash_type?
+
+          node.children.any? do |child|
+            child.respond_to?(:kwsplat_type?) && child.kwsplat_type?
+          end
+        end
+
+        def string_argument?(node)
+          node && !node.str_type?
+        end
+      end
+    end
+  end
+end

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

@@ -18,11 +18,11 @@ module RuboCop
         MSG = 'Use `flat_map` instead of `%s...%s`.'
         FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
                                   'and `flatten` can be used to flatten ' \
-                                  'multiple levels'
+                                  'multiple levels.'
         FLATTEN = [:flatten, :flatten!]
 
         def on_send(node)
-          left, second_method, flatten_param  = *node
+          left, second_method, flatten_param = *node
           return unless FLATTEN.include?(second_method)
           flatten_level, = *flatten_param
           expression, = *left
@@ -44,7 +44,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          receiver, _flatten, flatten_param  = *node
+          receiver, _flatten, flatten_param = *node
           flatten_level, = *flatten_param
           return if flatten_level.nil?
 

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

@@ -1,89 +1,133 @@
-# encoding: utf-8
+# encoding: UTF-8
 
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of `shuffle.first` and
-      # change them to use `sample` instead.
+      # 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[0]
-      #   [1, 2, 3].shuffle[0, 3]
-      #   [1, 2, 3].shuffle(random: Random.new(1))
+      #   [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].sample(random: Random.new(1))
+      #   [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 `sample` instead of `shuffle%s`.'
-        RANGE_TYPES = [:irange, :erange]
-        VALID_ARRAY_SELECTORS = [:first, :last, :[], nil]
+        MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
 
         def on_send(node)
-          _receiver, first_method, params, = *node
-          return unless first_method == :shuffle
-          _receiver, second_method, params, = *node.parent if params.nil?
-          return unless VALID_ARRAY_SELECTORS.include?(second_method)
-          return if second_method.nil? && params.nil?
-
-          add_offense(node, range_of_shuffle(node), message(node, params))
+          analyzer = ShuffleAnalyzer.new(node)
+          return unless analyzer.offensive?
+          add_offense(node, analyzer.source_range, analyzer.message)
         end
 
         def autocorrect(node)
-          _receiver, _method, params, selector = *node
-          _receiver, _method, params, selector = *node.parent if params.nil?
-
-          return if params && RANGE_TYPES.include?(params.type)
-
-          range = if params && (params.hash_type? || params.lvar_type?)
-                    range_of_shuffle(node)
-                  else
-                    Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                              node.loc.selector.begin_pos,
-                                              node.parent.loc.selector.end_pos)
-                  end
-
-          lambda do |corrector|
-            corrector.replace(range, 'sample')
-            return if selector.nil?
-            corrector.insert_after(range, "(#{selector.loc.expression.source})")
-          end
+          ShuffleAnalyzer.new(node).autocorrect
         end
 
-        private
-
-        def message(node, params)
-          if params && params.lvar_type?
-            format(MSG, shuffle_params(node))
-          elsif node.parent
-            _params, selector = *node.parent
-            if selector == :[]
-              format(MSG, node.parent.loc.selector.source)
-            else
-              format(MSG, ".#{node.parent.loc.selector.source}")
+        # An internal class for representing a shuffle + method node analyzer.
+        class ShuffleAnalyzer
+          def initialize(shuffle_node)
+            @shuffle_node = shuffle_node
+            @method_node  = shuffle_node.parent
+          end
+
+          def autocorrect
+            ->(corrector) { corrector.replace(source_range, correct) }
+          end
+
+          def message
+            format(MSG, correct: correct, incorrect: source_range.source)
+          end
+
+          def offensive?
+            shuffle_node.to_a[1] == :shuffle && corrigible?
+          end
+
+          def source_range
+            Parser::Source::Range.new(shuffle_node.loc.expression.source_buffer,
+                                      shuffle_node.loc.selector.begin_pos,
+                                      method_node.loc.expression.end_pos)
+          end
+
+          private
+
+          attr_reader :method_node, :shuffle_node
+
+          def correct
+            args = [sample_arg, shuffle_arg].compact.join(', ')
+            args.empty? ? 'sample' : "sample(#{args})"
+          end
+
+          def corrigible?
+            case method
+            when :first, :last then true
+            when :[]           then sample_size != :unknown
+            else false
             end
-          else
-            format(MSG, shuffle_params(node))
           end
-        end
 
-        def range_of_shuffle(node)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.loc.selector.begin_pos,
-                                    node.loc.selector.end_pos)
-        end
+          def method
+            method_node.to_a[1]
+          end
 
-        def shuffle_params(node)
-          params = Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                             node.loc.selector.end_pos,
-                                             node.loc.expression.end_pos)
+          def method_arg
+            _, _, arg = *method_node
+            arg.loc.expression.source if arg
+          end
+
+          # FIXME: use Range#size once Ruby 1.9 support is dropped
+          def range_size(range_node)
+            vals = *range_node
+            return :unknown unless vals.all?(&:int_type?)
+            low, high = *vals.map(&:to_a).map(&:first)
+            return :unknown unless low.zero? && high >= 0
+            case range_node.type
+            when :erange then high - low
+            when :irange then high - low + 1
+            end
+          end
 
-          params.source
+          def sample_arg
+            case method
+            when :first, :last then method_arg
+            when :[]           then sample_size
+            end
+          end
+
+          def sample_size
+            _, _, *args = *method_node
+            case args.size
+            when 1
+              arg = args.first
+              case arg.type
+              when :erange, :irange then range_size(arg)
+              when :int             then arg.to_a.first.zero? ? nil : :unknown
+              else :unknown
+              end
+            when 2
+              first, second = *args
+              return :unknown unless first.int_type? && first.to_a.first.zero?
+              second.int_type? ? second.to_a.first : :unknown
+            end
+          end
+
+          def shuffle_arg
+            _, _, arg = *shuffle_node
+            arg.loc.expression.source if arg
+          end
         end
       end
     end

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

@@ -27,12 +27,13 @@ module RuboCop
         MSG = 'Use `size` instead of `count`.'
 
         def on_send(node)
-          receiver, method = *node
+          receiver, method, args = *node
 
           return if receiver.nil?
           return unless method == :count
           return unless array?(receiver) || hash?(receiver)
           return if node.parent && node.parent.block_type?
+          return if args
 
           add_offense(node, node.loc.selector)
         end

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

@@ -0,0 +1,187 @@
+# encoding: utf-8
+
+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
+        MSG = 'Use `%s` instead of `%s`.'
+        DETERMINISTIC_REGEX = /^[\w\s\-,"']+$/.freeze
+        REGEXP_CONSTRUCTOR_METHODS = [:new, :compile].freeze
+        GSUB_METHODS = [:gsub, :gsub!].freeze
+        DETERMINISTIC_TYPES = [:regexp, :str, :send].freeze
+        DELETE = 'delete'.freeze
+        TR = 'tr'.freeze
+        BANG = '!'.freeze
+        SINGLE_QUOTE = "'".freeze
+
+        def on_send(node)
+          _string, method, first_param, second_param = *node
+          return unless GSUB_METHODS.include?(method)
+          return unless string?(second_param)
+          return unless DETERMINISTIC_TYPES.include?(first_param.type)
+
+          first_source, options = first_source(first_param)
+          second_source, = *second_param
+
+          return if first_source.nil?
+
+          if regex?(first_param)
+            return unless first_source =~ DETERMINISTIC_REGEX
+            return if options
+          end
+
+          return if first_source.length != 1
+          return unless second_source.length <= 1
+
+          message = message(method, first_source, second_source)
+          add_offense(node, range(node), message)
+        end
+
+        def autocorrect(node)
+          _string, method, first_param, second_param = *node
+          first_source, = first_source(first_param)
+          second_source, = *second_param
+          replacement_method = replacement_method(method,
+                                                  first_source,
+                                                  second_source)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.selector, replacement_method)
+            unless first_param.str_type?
+              corrector.replace(first_param.loc.expression,
+                                escape(first_source))
+            end
+
+            if second_source.empty? && first_source.length == 1
+              remove_second_param(corrector, node, first_param)
+            end
+          end
+        end
+
+        private
+
+        def string?(node)
+          node && node.str_type?
+        end
+
+        def first_source(first_param)
+          case first_param.type
+          when :regexp, :send
+            return nil unless regex?(first_param)
+
+            source, options = extract_source(first_param)
+          when :str
+            source, = *first_param
+          end
+
+          [source, options]
+        end
+
+        def extract_source(node)
+          case node.type
+          when :regexp
+            source_from_regex_literal(node)
+          when :send
+            source_from_regex_constructor(node)
+          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 regex?(node)
+          return true if node.regexp_type?
+
+          const, init, = *node
+          _, klass = *const
+
+          klass == :Regexp && REGEXP_CONSTRUCTOR_METHODS.include?(init)
+        end
+
+        def range(node)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    node.loc.selector.begin_pos,
+                                    node.loc.expression.end_pos)
+        end
+
+        def replacement_method(method, first_source, second_source)
+          replacement = if second_source.empty? && first_source.length == 1
+                          DELETE
+                        else
+                          TR
+                        end
+
+          "#{replacement}#{BANG if bang_method?(method)}"
+        end
+
+        def message(method, first_source, second_source)
+          replacement_method = replacement_method(method,
+                                                  first_source,
+                                                  second_source)
+
+          format(MSG, replacement_method, method)
+        end
+
+        def bang_method?(method)
+          method.to_s.end_with?(BANG)
+        end
+
+        def escape(string)
+          if require_double_quotes?(string)
+            string.inspect
+          else
+            "'#{string}'"
+          end
+        end
+
+        def require_double_quotes?(string)
+          string.inspect.include?(SINGLE_QUOTE) ||
+            StringHelp::ESCAPED_CHAR_REGEXP =~ string
+        end
+
+        def method_suffix(node)
+          node.loc.end ? node.loc.end.source : ''
+        end
+
+        def remove_second_param(corrector, node, first_param)
+          end_range =
+            Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                      first_param.loc.expression.end_pos,
+                                      node.loc.expression.end_pos)
+
+          corrector.replace(end_range, method_suffix(node))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/action_filter.rb

@@ -12,11 +12,37 @@ module RuboCop
 
         MSG = 'Prefer `%s` over `%s`.'
 
-        FILTER_METHODS = [:before_filter, :skip_before_filter,
-                          :after_filter, :around_filter]
-
-        ACTION_METHODS = [:before_action, :skip_before_action,
-                          :after_action, :around_action]
+        FILTER_METHODS = [
+          :after_filter,
+          :append_after_filter,
+          :append_around_filter,
+          :append_before_filter,
+          :around_filter,
+          :before_filter,
+          :prepend_after_filter,
+          :prepend_around_filter,
+          :prepend_before_filter,
+          :skip_after_filter,
+          :skip_around_filter,
+          :skip_before_filter,
+          :skip_filter
+        ]
+
+        ACTION_METHODS = [
+          :after_action,
+          :append_after_action,
+          :append_around_action,
+          :append_before_action,
+          :around_action,
+          :before_action,
+          :prepend_after_action,
+          :prepend_around_action,
+          :prepend_before_action,
+          :skip_after_action,
+          :skip_around_action,
+          :skip_before_action,
+          :skip_action_callback
+        ]
 
         def on_block(node)
           method, _args, _body = *node