rubocop 0.39.0 → 0.40.0

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

@@ -21,7 +21,7 @@ module RuboCop
         SINGLE_QUOTE = "'".freeze
 
         def_node_matcher :redundant_regex?, <<-END
-          {(send $_ {:match :=~} (regexp (str $#literal_at_end?) (regopt)))
+          {(send $!nil {:match :=~} (regexp (str $#literal_at_end?) (regopt)))
            (send (regexp (str $#literal_at_end?) (regopt)) {:match :=~} $_)}
         END
 

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

@@ -22,17 +22,7 @@ module RuboCop
         END
 
         def on_send(node)
-          redundant_merge(node) do |receiver, pairs|
-            if node.value_used?
-              parent = node.parent
-              grandparent = parent.parent if parent.begin_type?
-              second_arg = each_with_object_node(grandparent || parent)
-              next if second_arg.nil?
-              next unless receiver.loc.name.source == second_arg.loc.name.source
-            end
-            next if pairs.size > 1 && !receiver.pure?
-            next if pairs.size > max_key_value_pairs
-
+          each_redundant_merge(node) do |receiver, pairs|
             assignments = to_assignments(receiver, pairs).join('; ')
             message = format(MSG, assignments, node.source)
             add_offense(node, :expression, message)
@@ -62,6 +52,34 @@ module RuboCop
 
         private
 
+        def each_redundant_merge(node)
+          redundant_merge(node) do |receiver, pairs|
+            next if node.value_used? &&
+                    !value_used_inside_each_with_object?(node, receiver)
+            next if pairs.size > 1 && !receiver.pure?
+            next if pairs.size > max_key_value_pairs
+
+            yield receiver, pairs
+          end
+        end
+
+        def value_used_inside_each_with_object?(node, receiver)
+          while receiver.respond_to?(:send_type?) && receiver.send_type?
+            receiver, = *receiver
+          end
+
+          unless receiver.respond_to?(:lvar_type?) && receiver.lvar_type?
+            return false
+          end
+
+          parent = node.parent
+          grandparent = parent.parent if parent.begin_type?
+          second_arg = each_with_object_node(grandparent || parent)
+          return false if second_arg.nil?
+
+          receiver.loc.name.source == second_arg.loc.name.source
+        end
+
         def to_assignments(receiver, pairs)
           pairs.map do |pair|
             key, value = *pair

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

@@ -21,7 +21,7 @@ module RuboCop
         SINGLE_QUOTE = "'".freeze
 
         def_node_matcher :redundant_regex?, <<-END
-          {(send $_ {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
+          {(send $!nil {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
            (send (regexp (str $#literal_at_start?) (regopt)) {:match :=~} $_)}
         END
 

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

@@ -32,28 +32,12 @@ module RuboCop
 
         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
-            # This must be done after checking DETERMINISTIC_REGEX
-            # Otherwise things like \s will trip us up
-            first_source = interpret_string_escapes(first_source)
-          end
 
-          return if first_source.length != 1
-          return unless second_source.length <= 1
+          return unless GSUB_METHODS.include?(method)
+          return if accept_second_param?(second_param)
+          return if accept_first_param?(first_param)
 
-          message = message(method, first_source, second_source)
-          add_offense(node, range(node), message)
+          offense(node, method, first_param, second_param)
         end
 
         def autocorrect(node)
@@ -84,6 +68,41 @@ module RuboCop
 
         private
 
+        def accept_second_param?(second_param)
+          return true unless string?(second_param)
+          second_source, = *second_param
+
+          second_source.length > 1
+        end
+
+        def accept_first_param?(first_param)
+          return true unless DETERMINISTIC_TYPES.include?(first_param.type)
+
+          first_source, options = first_source(first_param)
+          return true if first_source.nil?
+
+          if regex?(first_param)
+            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, method, first_param, second_param)
+          first_source, = first_source(first_param)
+          if regex?(first_param)
+            first_source = interpret_string_escapes(first_source)
+          end
+          second_source, = *second_param
+          message = message(method, first_source, second_source)
+
+          add_offense(node, range(node), message)
+        end
+
         def string?(node)
           node && node.str_type?
         end

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

@@ -73,8 +73,7 @@ module RuboCop
           add_offense(node, :selector,
                       format(MSG,
                              preferred_method(method_name),
-                             method_name)
-                     )
+                             method_name))
         end
 
         def offending_method?(method_name)

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

@@ -65,9 +65,7 @@ module RuboCop
 
           add_offense(node, :selector,
                       format(MSG_SEND,
-                             method_name
-                            )
-                     )
+                             method_name))
         end
 
         private
@@ -81,8 +79,7 @@ module RuboCop
           add_offense(node, :selector,
                       format(MSG,
                              "Date.#{method_name}",
-                             "Time.zone.#{method_name}")
-                     )
+                             "Time.zone.#{method_name}"))
         end
 
         def extract_method_chain(node)

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

@@ -80,18 +80,15 @@ module RuboCop
           if acceptable?
             format(MSG_ACCEPTABLE,
                    "#{klass}.#{method_name}",
-                   acceptable_methods(klass, method_name, node).join(', ')
-                  )
+                   acceptable_methods(klass, method_name, node).join(', '))
           elsif method_name == 'current'
             format(MSG_CURRENT,
-                   "#{klass}.#{method_name}"
-                  )
+                   "#{klass}.#{method_name}")
           else
             safe_method_name = safe_method(method_name, node)
             format(MSG,
                    "#{klass}.#{method_name}",
-                   "Time.zone.#{safe_method_name}"
-                  )
+                   "Time.zone.#{safe_method_name}")
           end
         end
 

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Prefer the use of uniq before pluck instead of after.
+      #
+      # The use of uniq before pluck is preferred because it executes
+      # within the database.
+      #
+      # @example
+      #   # bad
+      #   Model.where(...).pluck(:id).uniq
+      #
+      #   # good
+      #   Model.where(...).uniq.pluck(:id)
+      #
+      class UniqBeforePluck < RuboCop::Cop::Cop
+        MSG = 'Use uniq before pluck'.freeze
+        DOT_UNIQ = '.uniq'.freeze
+        NEWLINE = "\n".freeze
+
+        def on_send(node)
+          receiver, method_name, *_args = *node
+
+          unless method_name == :uniq &&
+                 !receiver.nil? &&
+                 receiver.send_type? &&
+                 receiver.children[1] == :pluck
+            return
+          end
+          add_offense(node, :selector, MSG)
+        end
+
+        def autocorrect(node)
+          lines = node.source.split(NEWLINE)
+          begin_remove_pos = if lines.last.strip == DOT_UNIQ
+                               node.source.rindex(NEWLINE)
+                             else
+                               node.loc.dot.begin_pos
+                             end
+          receiver = node.children.first
+
+          lambda do |corrector|
+            corrector.remove(
+              Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                        begin_remove_pos,
+                                        node.loc.selector.end_pos)
+            )
+            corrector.insert_before(receiver.loc.dot.begin, DOT_UNIQ)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -27,8 +27,11 @@ module RuboCop
         def on_alias(node)
           # alias_method can't be used with global variables
           return if node.children.any?(&:gvar_type?)
+          # alias_method can't be used in instance_eval blocks
+          scope_type = scope_type(node)
+          return if scope_type == :instance_eval
 
-          if scope_type(node) == :dynamic || style == :prefer_alias_method
+          if scope_type == :dynamic || style == :prefer_alias_method
             add_offense(node, :keyword, MSG_ALIAS)
           elsif node.children.none? { |arg| bareword?(arg) }
             existing_args  = node.children.map(&:source).join(' ')
@@ -54,13 +57,17 @@ module RuboCop
 
         # In this expression, will `self` be the same as the innermost enclosing
         # class or module block (:lexical)? Or will it be something else
-        # (:dynamic)?
+        # (:dynamic)? If we're in an instance_eval block, return that.
         def scope_type(node)
           while (parent = node.parent)
             case parent.type
             when :class, :module
               return :lexical
-            when :def, :defs, :block
+            when :def, :defs
+              return :dynamic
+            when :block
+              return :instance_eval if parent.method_name == :instance_eval
+
               return :dynamic
             end
             node = parent

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

@@ -10,6 +10,12 @@ module RuboCop
         include AutocorrectAlignment
         include OnMethodDef
 
+        ALIGN_PARAMS_MSG = 'Align the parameters of a method %s if they span ' \
+          'more than one line.'.freeze
+
+        FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
+          'following the first line of a multi-line method %s.'.freeze
+
         def on_send(node)
           _receiver, method, *args = *node
 
@@ -27,8 +33,8 @@ module RuboCop
 
         def message(node)
           type = node && node.parent.send_type? ? 'call' : 'definition'
-          "Align the parameters of a method #{type} if they span " \
-          'more than one line.'
+          msg = fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
+          format(msg, type)
         end
 
         private

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

@@ -77,29 +77,27 @@ module RuboCop
 
         def correct_send(node, corrector)
           receiver, method_name, *args = *node
-          if method_name == :!
-            # ! is a special case:
-            # 'x and !obj.method arg' can be auto-corrected if we
-            # recurse down a level and add parens to 'obj.method arg'
-            # however, 'not x' also parses as (send x :!)
-
-            if node.loc.selector.source == '!'
-              node = receiver
-              return unless node.send_type?
-              _receiver, _method_name, *args = *node
-            elsif node.loc.selector.source == 'not'
-              return correct_other(node, corrector)
-            else
-              raise 'unrecognized unary negation operator'
-            end
-          end
+          return correct_not(node, receiver, corrector) if method_name == :!
           return unless correctable_send?(node)
 
-          sb = node.source_range.source_buffer
-          begin_paren = node.loc.selector.end_pos
-          range = Parser::Source::Range.new(sb, begin_paren, begin_paren + 1)
-          corrector.replace(range, '(')
-          corrector.insert_after(args.last.source_range, ')')
+          corrector.replace(whitespace_before_arg(node), '('.freeze)
+          corrector.insert_after(args.last.source_range, ')'.freeze)
+        end
+
+        # ! is a special case:
+        # 'x and !obj.method arg' can be auto-corrected if we
+        # recurse down a level and add parens to 'obj.method arg'
+        # however, 'not x' also parses as (send x :!)
+        def correct_not(node, receiver, corrector)
+          if node.loc.selector.source == '!'
+            return unless receiver.send_type?
+
+            correct_send(receiver, corrector)
+          elsif node.keyword_not?
+            correct_other(node, corrector)
+          else
+            raise 'unrecognized unary negation operator'
+          end
         end
 
         def correct_other(node, corrector)
@@ -117,6 +115,16 @@ module RuboCop
 
           true
         end
+
+        def whitespace_before_arg(node)
+          sb = node.source_range.source_buffer
+          begin_paren = node.loc.selector.end_pos
+          end_paren = begin_paren
+          # Increment position of parenthesis, unless message is a predicate
+          # method followed by a non-whitespace char (e.g. is_a?String).
+          end_paren += 1 unless node.source =~ /\?[!\S]/
+          Parser::Source::Range.new(sb, begin_paren, end_paren)
+        end
       end
     end
   end

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

@@ -28,7 +28,7 @@ module RuboCop
 
         def on_class(node)
           _name, superclass, body = *node
-          return if superclass
+          return if superclass && style != :nested
           check_style(node, body)
         end
 

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

@@ -44,8 +44,7 @@ module RuboCop
           add_offense(node, :selector,
                       format(MSG,
                              preferred_method(method_name),
-                             method_name)
-                     )
+                             method_name))
         end
       end
     end

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

@@ -52,7 +52,7 @@ module RuboCop
         end
 
         def less_indented?(line)
-          line =~ /^\s*(end\b|[\}\]])/
+          line =~ /^\s*(end\b|[)}\]])/
         end
 
         def two_alternatives?(line)

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

@@ -275,7 +275,7 @@ module RuboCop
         private
 
         def move_assignment_outside_condition(node)
-          if ternary_op?(node)
+          if ternary?(node)
             TernaryCorrector.correct(node)
           elsif node.loc.keyword.is?(IF)
             IfCorrector.correct(self, node)
@@ -288,7 +288,7 @@ module RuboCop
 
         def move_assignment_inside_condition(node)
           *_assignment, condition = *node
-          if ternary_op?(condition) || ternary_op?(condition.children[0])
+          if ternary?(condition) || ternary?(condition.children[0])
             TernaryCorrector.move_assignment_inside_condition(node)
           elsif condition.case_type?
             CaseCorrector.move_assignment_inside_condition(node)
@@ -465,12 +465,8 @@ module RuboCop
           include ConditionalCorrectorHelper
 
           def correct(cop, node)
-            _condition, if_branch, else_branch = *node
-            if_branch = tail(if_branch)
+            if_branch, elsif_branches, else_branch = extract_branches(node)
             _variable, *_operator, if_assignment = *if_branch
-            elsif_branches, else_branch = expand_elses(else_branch)
-            elsif_branches.map! { |branch| tail(branch) }
-            else_branch = tail(else_branch)
             _else_variable, *_operator, else_assignment = *else_branch
 
             lambda do |corrector|
@@ -507,6 +503,16 @@ module RuboCop
               end
             end
           end
+
+          private
+
+          def extract_branches(node)
+            _condition, if_branch, else_branch = *node
+            elsif_branches, else_branch = expand_elses(else_branch)
+            elsif_branches.map! { |branch| tail(branch) }
+
+            [tail(if_branch), elsif_branches, tail(else_branch)]
+          end
         end
       end