rubocop 0.33.0 → 0.34.0

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

@@ -0,0 +1,132 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # Place `when` conditions that use splat at the end
+      # of the list of `when` branches.
+      #
+      # Ruby has to allocate memory for the splat expansion every time
+      # that the `case` `when` statement is run. Since Ruby does not support
+      # fall through inside of `case` `when`, like some other languages do,
+      # the order of the `when` branches does not matter. By placing any
+      # splat expansions at the end of the list of `when` branches we will
+      # reduce the number of times that memory has to be allocated for
+      # the expansion.
+      #
+      # This is not a guaranteed performance improvement. If the data being
+      # processed by the `case` condition is normalized in a manner that favors
+      # hitting a condition in the splat expansion, it is possible that
+      # moving the splat condition to the end will use more memory,
+      # and run slightly slower.
+      #
+      # @example
+      #   # bad
+      #   case foo
+      #   when *condition
+      #     bar
+      #   when baz
+      #     foobar
+      #   end
+      #
+      #   case foo
+      #   when *[1, 2, 3, 4]
+      #     bar
+      #   when 5
+      #     baz
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when baz
+      #     foobar
+      #   when *condition
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when 1, 2, 3, 4
+      #     bar
+      #   when 5
+      #     baz
+      #   end
+      class CaseWhenSplat < Cop
+        include AutocorrectAlignment
+
+        MSG = 'Place `when` conditions with a splat ' \
+              'at the end of the `when` branches.'.freeze
+        ARRAY_MSG = 'Do not expand array literals in `when` conditions.'.freeze
+
+        def on_case(node)
+          _case_branch, *when_branches, _else_branch = *node
+          when_conditions =
+            when_branches.each_with_object([]) do |branch, conditions|
+              condition, = *branch
+              conditions << condition
+            end
+
+          splat_offenses(when_conditions).reverse_each do |condition|
+            range = condition.parent.loc.keyword.join(condition.loc.expression)
+            variable, = *condition
+            message = variable.array_type? ? ARRAY_MSG : MSG
+            add_offense(condition.parent, range, message)
+          end
+        end
+
+        def autocorrect(node)
+          condition, = *node
+          variable, = *condition
+          if variable.array_type?
+            correct_array_literal(condition, variable)
+          else
+            reorder_splat_condition(node)
+          end
+        end
+
+        private
+
+        def splat_offenses(when_conditions)
+          found_non_splat = false
+          when_conditions.reverse.each_with_object([]) do |condition, result|
+            found_non_splat ||= true if error_condition?(condition)
+
+            next unless condition.splat_type?
+            result << condition if found_non_splat
+          end
+        end
+
+        def error_condition?(condition)
+          variable, = *condition
+
+          (condition.splat_type? && variable.array_type?) ||
+            !condition.splat_type?
+        end
+
+        def correct_array_literal(condition, variable)
+          lambda do |corrector|
+            corrector.remove(condition.loc.operator)
+            corrector.remove(variable.loc.begin)
+            corrector.remove(variable.loc.end)
+          end
+        end
+
+        def reorder_splat_condition(node)
+          _case_branch, *when_branches, _else_branch = *node.parent
+          current_index = when_branches.index { |branch| branch == node }
+          next_branch = when_branches[current_index + 1]
+          correction = "\n#{offset(node)}#{node.loc.expression.source}"
+          range =
+            Parser::Source::Range.new(node.parent,
+                                      node.loc.expression.begin_pos,
+                                      next_branch.loc.expression.begin_pos)
+
+          lambda do |corrector|
+            corrector.remove(range)
+            corrector.insert_after(when_branches.last.loc.expression,
+                                   correction)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -20,10 +20,15 @@ module RuboCop
       #   'a b c'.delete(' ')
       class StringReplacement < Cop
         MSG = 'Use `%s` instead of `%s`.'
-        DETERMINISTIC_REGEX = /^[\w\s\-,."']+$/
-        REGEXP_CONSTRUCTOR_METHODS = [:new, :compile]
-        GSUB_METHODS = [:gsub, :gsub!]
-        DETERMINISTIC_TYPES = [:regexp, :str, :send]
+        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
+        CLOSING_PAREN = ')'.freeze
 
         def on_send(node)
           _string, method, first_param, second_param = *node
@@ -51,19 +56,20 @@ module RuboCop
           _string, method, first_param, second_param = *node
           first_source = first_source(first_param)
           second_source, = *second_param
-          replacement_method = replacement_method(first_source, second_source)
+          replacement_method = replacement_method(method,
+                                                  first_source,
+                                                  second_source)
 
           lambda do |corrector|
-            replacement =
-              if second_source.empty? && first_source.length == 1
-                "#{replacement_method}#{'!' if bang_method?(method)}" \
-                "(#{escape(first_source)})"
-              else
-                "#{replacement_method}#{'!' if bang_method?(method)}" \
-                "(#{escape(first_source)}, #{escape(second_source)})"
-              end
-
-            corrector.replace(range(node), replacement)
+            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
 
@@ -123,24 +129,26 @@ module RuboCop
                                     node.loc.expression.end_pos)
         end
 
-        def replacement_method(first_source, second_source)
-          if second_source.empty? && first_source.length == 1
-            'delete'
-          else
-            'tr'
-          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(first_source, second_source)
+          replacement_method = replacement_method(method,
+                                                  first_source,
+                                                  second_source)
 
-          format(MSG,
-                 "#{replacement_method}#{'!' if bang_method?(method)}",
-                 method)
+          format(MSG, replacement_method, method)
         end
 
         def bang_method?(method)
-          method.to_s.end_with?('!')
+          method.to_s.end_with?(BANG)
         end
 
         def escape(string)
@@ -152,8 +160,17 @@ module RuboCop
         end
 
         def require_double_quotes?(string)
-          /'/ =~ string.inspect ||
-            StringHelp::ESCAPED_CHAR_REGEXP =~ string.inspect
+          string.inspect.include?(SINGLE_QUOTE) ||
+            StringHelp::ESCAPED_CHAR_REGEXP =~ string
+        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, CLOSING_PAREN)
         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

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

@@ -33,15 +33,15 @@ module RuboCop
       #   Date.today
       #   date.to_time
       #
-      #   # reports offense only when style is 'always'
+      #   # reports offense only when style is 'strict'
       #   date.to_time_in_current_zone
       class Date < Cop
         include ConfigurableEnforcedStyle
 
         MSG = 'Do not use `%s` without zone. Use `%s` instead.'
 
-        MSG_SEND =  'Do not use `%s` on Date objects,' \
-                    'because it knows nothing about time zone in use.'
+        MSG_SEND =  'Do not use `%s` on Date objects, ' \
+                    'because they know nothing about the time zone in use.'
 
         BAD_DAYS = [:today, :current, :yesterday, :tomorrow]
 
@@ -54,8 +54,9 @@ module RuboCop
         end
 
         def on_send(node)
-          receiver, method_name, *_args = *node
+          receiver, method_name, *args = *node
           return unless receiver && bad_methods.include?(method_name)
+          return if method_name == :to_time && args.length == 1
 
           add_offense(node, :selector,
                       format(MSG_SEND,
@@ -96,7 +97,7 @@ module RuboCop
         # checks that parent node of send_type
         # and receiver is the given node
         def method_send?(node)
-          return false unless node.parent.send_type?
+          return false unless node.parent && node.parent.send_type?
 
           receiver, _method_name, *_args = *node.parent
 

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

@@ -33,7 +33,7 @@ module RuboCop
           if method_name == :read_attribute
             format(MSG, 'self[:attr]', 'read_attribute(:attr)')
           else
-            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, var)')
+            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
           end
         end
 

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

@@ -66,6 +66,8 @@ module RuboCop
 
           method_name = (chain & DANGEROUS_METHODS).join('.')
 
+          return if offset_provided?(node)
+
           message = build_message(klass, method_name, node)
 
           add_offense(node, :selector, message)
@@ -107,7 +109,7 @@ module RuboCop
         # checks that parent node of send_type
         # and receiver is the given node
         def method_send?(node)
-          return false unless node.parent.send_type?
+          return false unless node.parent && node.parent.send_type?
 
           receiver, _method_name, *_args = *node.parent
 
@@ -163,6 +165,15 @@ module RuboCop
 
           acceptable
         end
+
+        # Time.new can be called with a time zone offset
+        # When it is, that should be considered safe
+        # Example:
+        # Time.new(1988, 3, 15, 3, 0, 0, "-05:00")
+        def offset_provided?(node)
+          _, _, *args = *node
+          args.length >= 7
+        end
       end
     end
   end

data/lib/rubocop/cop/style/alias.rb

@@ -15,6 +15,7 @@ module RuboCop
           # using alias is the only option in certain scenarios
           # in such scenarios we don't want to report an offense
           return unless method_name == :instance_exec
+          return unless body
 
           body.each_node(:alias) { |n| ignore_node(n) }
         end

data/lib/rubocop/cop/style/block_delimiters.rb

@@ -59,11 +59,8 @@ module RuboCop
             b = node.loc.begin
             e = node.loc.end
             if b.is?('{')
-              # If the left brace is not preceded by a whitespace character,
-              # then we need a space before `do` to get valid Ruby code.
-              if b.source_buffer.source[b.begin_pos - 1, 1] =~ /\S/
-                corrector.insert_before(b, ' ')
-              end
+              corrector.insert_before(b, ' ') unless whitespace_before?(b)
+              corrector.insert_before(e, ' ') unless whitespace_before?(e)
               corrector.replace(b, 'do')
               corrector.replace(e, 'end')
             else
@@ -73,6 +70,10 @@ module RuboCop
           end
         end
 
+        def whitespace_before?(node)
+          node.source_buffer.source[node.begin_pos - 1, 1] =~ /\s/
+        end
+
         def get_block(node)
           case node.type
           when :block

data/lib/rubocop/cop/style/collection_methods.rb

@@ -10,6 +10,8 @@ module RuboCop
       # Enumerable or not (static analysis limitation), so this cop
       # can yield some false positives.
       class CollectionMethods < Cop
+        include MethodPreference
+
         MSG = 'Prefer `%s` over `%s`.'
 
         def on_block(node)
@@ -44,26 +46,6 @@ module RuboCop
                              method_name)
                      )
         end
-
-        def preferred_method(method)
-          preferred_methods[method.to_sym]
-        end
-
-        def preferred_methods
-          @preferred_methods ||=
-            begin
-              # Make sure default configuration 'foo' => 'bar' is removed from
-              # the total configuration if there is a 'bar' => 'foo' override.
-              default = default_cop_config['PreferredMethods']
-              merged = cop_config['PreferredMethods']
-              overrides = merged.values - default.values
-              merged.reject { |key, _| overrides.include?(key) }.symbolize_keys
-            end
-        end
-
-        def default_cop_config
-          ConfigLoader.default_configuration[cop_name]
-        end
       end
     end
   end

data/lib/rubocop/cop/style/else_alignment.rb

@@ -8,6 +8,7 @@ module RuboCop
       # are special cases when they should follow the same rules as the
       # alignment of end.
       class ElseAlignment < Cop
+        include EndKeywordAlignment
         include AutocorrectAlignment
         include CheckAssignment
 
@@ -86,7 +87,7 @@ module RuboCop
 
           end_config = config.for_cop('Lint/EndAlignment')
           style = end_config['Enabled'] ? end_config['AlignWith'] : 'keyword'
-          base = style == 'variable' ? node : rhs
+          base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
           return if rhs.type != :if