rubocop 0.51.0 → 0.52.0

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

@@ -14,60 +14,54 @@ module RuboCop
       #
       #   # bad
       #   "<p>#{user_content}</p>".html_safe
-      #   => ActiveSupport::SafeBuffer
-      #   "<p><b>hi</b></p>"
+      #   # => ActiveSupport::SafeBuffer "<p><b>hi</b></p>"
       #
       #   # good
       #   content_tag(:p, user_content)
-      #   => ActiveSupport::SafeBuffer
-      #   "<p>&lt;b&gt;hi&lt;/b&gt;</p>"
+      #   # => ActiveSupport::SafeBuffer "<p>&lt;b&gt;hi&lt;/b&gt;</p>"
       #
       #   # bad
       #   out = ""
       #   out << "<li>#{user_content}</li>"
       #   out << "<li>#{user_content}</li>"
       #   out.html_safe
-      #   => ActiveSupport::SafeBuffer
-      #   "<li><b>hi</b></li><li><b>hi</b></li>"
+      #   # => ActiveSupport::SafeBuffer "<li><b>hi</b></li><li><b>hi</b></li>"
       #
       #   # good
       #   out = []
       #   out << content_tag(:li, user_content)
       #   out << content_tag(:li, user_content)
       #   safe_join(out)
-      #   => ActiveSupport::SafeBuffer
-      #   "<li>&lt;b&gt;hi&lt;/b&gt;</li><li>&lt;b&gt;hi&lt;/b&gt;</li>"
+      #   # => ActiveSupport::SafeBuffer
+      #   #    "<li>&lt;b&gt;hi&lt;/b&gt;</li><li>&lt;b&gt;hi&lt;/b&gt;</li>"
       #
       #   # bad
       #   out = "<h1>trusted content</h1>".html_safe
       #   out.safe_concat(user_content)
-      #   => ActiveSupport::SafeBuffer
-      #   "<h1>trusted_content</h1><b>hi</b>"
+      #   # => ActiveSupport::SafeBuffer "<h1>trusted_content</h1><b>hi</b>"
       #
       #   # good
       #   out = "<h1>trusted content</h1>".html_safe
       #   out.concat(user_content)
-      #   => ActiveSupport::SafeBuffer
-      #   "<h1>trusted_content</h1>&lt;b&gt;hi&lt;/b&gt;"
+      #   # => ActiveSupport::SafeBuffer
+      #   #    "<h1>trusted_content</h1>&lt;b&gt;hi&lt;/b&gt;"
       #
       #   # safe, though maybe not good style
       #   out = "trusted content"
       #   result = out.concat(user_content)
-      #   => String "trusted content<b>hi</b>"
+      #   # => String "trusted content<b>hi</b>"
       #   # because when rendered in ERB the String will be escaped:
-      #   <%= result %>
-      #   => trusted content&lt;b&gt;hi&lt;/b&gt;
+      #   # <%= result %>
+      #   # => trusted content&lt;b&gt;hi&lt;/b&gt;
       #
       #   # bad
       #   (user_content + " " + content_tag(:span, user_content)).html_safe
-      #   => ActiveSupport::SafeBuffer
-      #   "<b>hi</b> <span><b>hi</b></span>"
+      #   # => ActiveSupport::SafeBuffer "<b>hi</b> <span><b>hi</b></span>"
       #
       #   # good
       #   safe_join([user_content, " ", content_tag(:span, user_content)])
-      #   => ActiveSupport::SafeBuffer
-      #   "&lt;b&gt;hi&lt;/b&gt; <span>&lt;b&gt;hi&lt;/b&gt;</span>"
-      #
+      #   # => ActiveSupport::SafeBuffer
+      #   #    "&lt;b&gt;hi&lt;/b&gt; <span>&lt;b&gt;hi&lt;/b&gt;</span>"
       class OutputSafety < Cop
         MSG = 'Tagging a string as html safe may be a security risk.'.freeze
 

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

@@ -37,14 +37,6 @@ module RuboCop
           add_offense(node)
         end
 
-        private
-
-        def message(node)
-          number, = *node.receiver
-
-          format(MSG, number, correct_method(node.method_name.to_s))
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             method_name = node.loc.selector.source
@@ -53,6 +45,14 @@ module RuboCop
           end
         end
 
+        private
+
+        def message(node)
+          number, = *node.receiver
+
+          format(MSG, number, correct_method(node.method_name.to_s))
+        end
+
         def correct_method(method_name)
           if plural_method?(method_name)
             singularize(method_name)

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks code that can be written more easily using
+      # `Object#presence` defined by Active Support.
+      #
+      # @example
+      #   # bad
+      #   a.present? ? a : nil
+      #
+      #   # bad
+      #   !a.present? ? nil : a
+      #
+      #   # bad
+      #   a.blank? ? nil : a
+      #
+      #   # bad
+      #   !a.blank? ? a : nil
+      #
+      #   # good
+      #   a.presence
+      #
+      # @example
+      #   # bad
+      #   a.present? ? a : b
+      #
+      #   # bad
+      #   !a.present? ? b : a
+      #
+      #   # bad
+      #   a.blank? ? b : a
+      #
+      #   # bad
+      #   !a.blank? ? a : b
+      #
+      #   # good
+      #   a.presence || b
+      class Presence < Cop
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
+
+        def_node_matcher :redundant_receiver_and_other, <<-PATTERN
+          {
+            (if
+              (send $_recv :present?)
+              _recv
+              $_false
+            )
+            (if
+              (send $_recv :blank?)
+              $_true
+              _recv
+            )
+          }
+        PATTERN
+
+        def_node_matcher :redundant_negative_receiver_and_other, <<-PATTERN
+          {
+            (if
+              (send (send $_recv :present?) :!)
+              $_true
+              _recv
+            )
+            (if
+              (send (send $_recv :blank?) :!)
+              _recv
+              $_false
+            )
+          }
+        PATTERN
+
+        def on_if(node)
+          receiver, other = redundant_receiver_and_other(node)
+          unless receiver
+            receiver, other = redundant_negative_receiver_and_other(node)
+          end
+          return unless receiver
+          message = format(MSG,
+                           prefer: replacement(receiver, other),
+                           current: node.source)
+          add_offense(node, message: message)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            receiver, other = redundant_receiver_and_other(node)
+            unless receiver
+              receiver, other = redundant_negative_receiver_and_other(node)
+            end
+            return unless receiver
+            corrector.replace(node.source_range, replacement(receiver, other))
+          end
+        end
+
+        private
+
+        def replacement(receiver, other)
+          or_source = other.nil_type? ? '' : " || #{other.source}"
+          "#{receiver.source}.presence" + or_source
+        end
+      end
+    end
+  end
+end

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

@@ -31,16 +31,6 @@ module RuboCop
           add_offense(node, location: :selector)
         end
 
-        private
-
-        def message(node)
-          if node.method?(:read_attribute)
-            format(MSG, 'self[:attr]', 'read_attribute(:attr)')
-          else
-            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
-          end
-        end
-
         def autocorrect(node)
           case node.method_name
           when :read_attribute
@@ -52,6 +42,16 @@ module RuboCop
           ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
+        private
+
+        def message(node)
+          if node.method?(:read_attribute)
+            format(MSG, 'self[:attr]', 'read_attribute(:attr)')
+          else
+            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
+          end
+        end
+
         def read_attribute_replacement(node)
           "self[#{node.first_argument.source}]"
         end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for redundant receiver in `with_options`.
+      # Receiver is implicit from Rails 4.2 or higher.
+      #
+      # @example
+      #   # bad
+      #   class Account < ApplicationRecord
+      #     with_options dependent: :destroy do |assoc|
+      #       assoc.has_many :customers
+      #       assoc.has_many :products
+      #       assoc.has_many :invoices
+      #       assoc.has_many :expenses
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Account < ApplicationRecord
+      #     with_options dependent: :destroy do
+      #       has_many :customers
+      #       has_many :products
+      #       has_many :invoices
+      #       has_many :expenses
+      #     end
+      #   end
+      class RedundantReceiverInWithOptions < Cop
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 4.2
+
+        MSG = 'Redundant receiver in `with_options`.'.freeze
+
+        def_node_matcher :with_options?, <<-PATTERN
+          (block
+            (send nil? :with_options
+              (...))
+            (args
+              (...))
+            ...)
+        PATTERN
+
+        def_node_search :assoc_has_redundant_receiver, <<-PATTERN
+          (send
+            (lvar _) ...)
+        PATTERN
+
+        def on_block(node)
+          with_options?(node) do
+            assoc_has_redundant_receiver(node).each do |assoc|
+              add_offense(assoc, location: assoc.receiver.loc.expression)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.receiver.loc.expression)
+            corrector.remove(node.loc.dot)
+            corrector.remove(block_argument_range(node))
+          end
+        end
+
+        private
+
+        def block_argument_range(node)
+          block_argument = node.parent.parent.children[1].loc.expression
+
+          range_between(
+            search_begin_pos_of_space_before_block_argument(
+              block_argument.begin_pos
+            ),
+            block_argument.end_pos
+          )
+        end
+
+        def search_begin_pos_of_space_before_block_argument(begin_pos)
+          position = begin_pos - 1
+
+          if processed_source.raw_source[position] == ' '
+            search_begin_pos_of_space_before_block_argument(position)
+          else
+            begin_pos
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -51,6 +51,15 @@ module RuboCop
           check_node(rhs)
         end
 
+        def autocorrect(node)
+          _scope, const_name, value = *node
+          indent = ' ' * node.loc.column
+          new_code = ["def self.#{const_name.downcase}",
+                      "#{indent}#{value.source}",
+                      'end'].join("\n#{indent}")
+          ->(corrector) { corrector.replace(node.source_range, new_code) }
+        end
+
         private
 
         def check_node(node)
@@ -73,15 +82,6 @@ module RuboCop
             RELATIVE_DATE_METHODS.include?(node.method_name) &&
             !node.arguments?
         end
-
-        def autocorrect(node)
-          _scope, const_name, value = *node
-          indent = ' ' * node.loc.column
-          new_code = ["def self.#{const_name.downcase}",
-                      "#{indent}#{value.source}",
-                      'end'].join("\n#{indent}")
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
-        end
       end
     end
   end

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

@@ -256,8 +256,7 @@ module RuboCop
 
         def within_change_method?(node)
           node.each_ancestor(:def).any? do |ancestor|
-            method_name, = *ancestor
-            method_name == :change
+            ancestor.method?(:change)
           end
         end
 
@@ -270,8 +269,8 @@ module RuboCop
         def all_hash_key?(args, *keys)
           return false unless args && args.hash_type?
 
-          hash_keys = args.to_a.map do |arg|
-            arg.to_a.first.children.first.to_sym
+          hash_keys = args.keys.map do |key|
+            key.children.first.to_sym
           end
 
           hash_keys & keys == keys

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

@@ -51,17 +51,14 @@ module RuboCop
         minimum_target_ruby_version 2.3
 
         def on_send(node)
-          try_call(node) do |try_method, method_to_try|
+          try_call(node) do |try_method, dispatch|
             return if try_method == :try && !cop_config['ConvertTry']
-            return unless method_to_try.sym_type?
-            method, = *method_to_try
-            return unless method =~ /\w+[=!?]?/
+            return unless dispatch.sym_type? && dispatch.value =~ /\w+[=!?]?/
+
             add_offense(node, message: format(MSG, try_method))
           end
         end
 
-        private
-
         def autocorrect(node)
           method_node, *params = *node.arguments
           method = method_node.source[1..-1]
@@ -74,6 +71,8 @@ module RuboCop
           end
         end
 
+        private
+
         def replacement(method, params)
           new_params = params.map(&:source).join(', ')
 

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

@@ -24,7 +24,7 @@ module RuboCop
       #
       #   # good
       #   unless user.save
-      #      . . .
+      #     # ...
       #   end
       #   user.save!
       #   user.update!(name: 'Joe')
@@ -33,7 +33,7 @@ module RuboCop
       #
       #   user = User.find_or_create_by(name: 'Joe')
       #   unless user.persisted?
-      #      . . .
+      #     # ...
       #   end
       class SaveBang < Cop
         MSG = 'Use `%s` instead of `%s` if the return value is not checked.'

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

@@ -26,7 +26,7 @@ module RuboCop
       #
       # @example
       #   # this will return a Relation that pluck is called on
-      #   Model.where(...).pluck(:id).uniq
+      #   Model.where(cond: true).pluck(:id).uniq
       #
       #   # an association on an instance will return a CollectionProxy
       #   instance.assoc.pluck(:id).uniq