rubocop 0.49.1 → 0.52.0

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that methods specified in the filter's `only`
+      # or `except` options are explicitly defined in the controller.
+      #
+      # You can specify methods of superclass or methods added by mixins
+      # on the filter, but these confuse developers. If you specify methods
+      # where are defined on another controller, you should define the filter
+      # in that controller.
+      #
+      # @example
+      #   # bad
+      #   class LoginController < ApplicationController
+      #     before_action :require_login, only: %i[index settings logout]
+      #
+      #     def index
+      #     end
+      #   end
+      #
+      #   # good
+      #   class LoginController < ApplicationController
+      #     before_action :require_login, only: %i[index settings logout]
+      #
+      #     def index
+      #     end
+      #
+      #     def settings
+      #     end
+      #
+      #     def logout
+      #     end
+      #   end
+      class LexicallyScopedActionFilter < Cop
+        MSG = '%s not explicitly defined on the controller.'.freeze
+
+        FILTERS = %w[
+          :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
+        ].freeze
+
+        def_node_matcher :only_or_except_filter_methods, <<-PATTERN
+          (send
+            nil?
+            {#{FILTERS.join(' ')}}
+            _
+            (hash
+              (pair
+                (sym {:only :except})
+                $_)))
+        PATTERN
+
+        def on_send(node)
+          methods_node = only_or_except_filter_methods(node)
+          return unless methods_node
+
+          defined_methods = node.parent.each_child_node(:def).map(&:method_name)
+          methods = array_values(methods_node).reject do |method|
+            defined_methods.include?(method)
+          end
+
+          add_offense(node, message: message(methods)) unless methods.empty?
+        end
+
+        private
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Array<Symbol>]
+        def array_values(node) # rubocop:disable Metrics/MethodLength
+          case node.type
+          when :str
+            [node.str_content.to_sym]
+          when :sym
+            [node.value]
+          when :array
+            node.values.map do |v|
+              case v.type
+              when :str
+                v.str_content.to_sym
+              when :sym
+                v.value
+              end
+            end.compact
+          else
+            []
+          end
+        end
+
+        def message(methods)
+          if methods.size == 1
+            format(MSG, "`#{methods[0]}` is")
+          else
+            format(MSG, "`#{methods.join('`, `')}` are")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -20,19 +20,19 @@ module RuboCop
         MSG = 'Do not add a NOT NULL column without a default value.'.freeze
 
         def_node_matcher :add_not_null_column?, <<-PATTERN
-          (send nil :add_column _ _ _ (hash $...))
+          (send nil? :add_column _ _ _ (hash $...))
         PATTERN
 
         def_node_matcher :add_not_null_reference?, <<-PATTERN
-          (send nil :add_reference _ _ (hash $...))
+          (send nil? :add_reference _ _ (hash $...))
         PATTERN
 
         def_node_matcher :null_false?, <<-PATTERN
           (pair (sym :null) (false))
         PATTERN
 
-        def_node_matcher :has_default?, <<-PATTERN
-          (pair (sym :default) !(:nil))
+        def_node_matcher :default_option?, <<-PATTERN
+          (pair (sym :default) !nil)
         PATTERN
 
         def on_send(node)
@@ -54,12 +54,12 @@ module RuboCop
 
         def check_pairs(pairs)
           return unless pairs
-          return if pairs.any? { |pair| has_default?(pair) }
+          return if pairs.any? { |pair| default_option?(pair) }
 
           null_false = pairs.find { |pair| null_false?(pair) }
           return unless null_false
 
-          add_offense(null_false, :expression)
+          add_offense(null_false)
         end
       end
     end

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

@@ -4,18 +4,27 @@ module RuboCop
   module Cop
     module Rails
       # This cop checks for the use of output calls like puts and print
+      #
+      # @example
+      #   # bad
+      #   puts 'A debug message'
+      #   pp 'A debug message'
+      #   print 'A debug message'
+      #
+      #   # good
+      #   Rails.logger.debug 'A debug message'
       class Output < Cop
         MSG = 'Do not write to stdout. ' \
               "Use Rails's logger if you want to log.".freeze
 
         def_node_matcher :output?, <<-PATTERN
-          (send nil {:ap :p :pp :pretty_print :print :puts} ...)
+          (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
         PATTERN
 
         def on_send(node)
           return unless output?(node) && node.arguments?
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
       end
     end

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
 
@@ -76,8 +70,9 @@ module RuboCop
                         looks_like_rails_raw?(node) ||
                         looks_like_rails_safe_concat?(node)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
+        alias on_csend on_send
 
         private
 

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

@@ -34,15 +34,7 @@ module RuboCop
 
           return unless offense?(node)
 
-          add_offense(node, :expression)
-        end
-
-        private
-
-        def message(node)
-          number, = *node.receiver
-
-          format(MSG, number, correct_method(node.method_name.to_s))
+          add_offense(node)
         end
 
         def autocorrect(node)
@@ -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)
@@ -77,7 +77,7 @@ module RuboCop
         end
 
         def singular_receiver?(number)
-          number == 1
+          number.abs == 1
         end
 
         def plural_receiver?(number)

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/present.rb

@@ -36,15 +36,15 @@ module RuboCop
       #     something if  foo.present?
       class Present < Cop
         MSG_NOT_BLANK = 'Use `%s` instead of `%s`.'.freeze
-        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%s.present?` instead of `%s`.'.freeze
-        MSG_UNLESS_BLANK = 'Use `if %s.present?` instead of `%s`.'.freeze
+        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%s` instead of `%s`.'.freeze
+        MSG_UNLESS_BLANK = 'Use `if %s` instead of `%s`.'.freeze
 
         def_node_matcher :exists_and_not_empty?, <<-PATTERN
           (and
               {
                 (send (send $_ :nil?) :!)
                 (send (send $_ :!) :!)
-                (send $_ :!= (:nil))
+                (send $_ :!= nil)
                 $_
               }
               {
@@ -56,7 +56,7 @@ module RuboCop
         def_node_matcher :not_blank?, '(send (send $_ :blank?) :!)'
 
         def_node_matcher :unless_blank?, <<-PATTERN
-          (:if $(send $_ :blank?) {nil (...)} ...)
+          (:if $(send $_ :blank?) {nil? (...)} ...)
         PATTERN
 
         def on_send(node)
@@ -64,10 +64,9 @@ module RuboCop
 
           not_blank?(node) do |receiver|
             add_offense(node,
-                        :expression,
-                        format(MSG_NOT_BLANK,
-                               replacement(receiver),
-                               node.source))
+                        message: format(MSG_NOT_BLANK,
+                                        replacement(receiver),
+                                        node.source))
           end
         end
 
@@ -78,10 +77,9 @@ module RuboCop
             return unless variable1 == variable2
 
             add_offense(node,
-                        :expression,
-                        format(MSG_EXISTS_AND_NOT_EMPTY,
-                               variable1.source,
-                               node.source))
+                        message: format(MSG_EXISTS_AND_NOT_EMPTY,
+                                        replacement(variable1),
+                                        node.source))
           end
         end
 
@@ -91,7 +89,7 @@ module RuboCop
           exists_and_not_empty?(node) do |variable1, variable2|
             return unless variable1 == variable2
 
-            add_offense(node, :expression, MSG_EXISTS_AND_NOT_EMPTY)
+            add_offense(node, message: MSG_EXISTS_AND_NOT_EMPTY)
           end
         end
 
@@ -101,9 +99,8 @@ module RuboCop
 
           unless_blank?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)
-            add_offense(node,
-                        range,
-                        format(MSG_UNLESS_BLANK, receiver.source, range.source))
+            msg = format(MSG_UNLESS_BLANK, replacement(receiver), range.source)
+            add_offense(node, location: range, message: msg)
           end
         end
 
@@ -111,7 +108,7 @@ module RuboCop
           lambda do |corrector|
             method_call, variable1 = unless_blank?(node)
 
-            if method_call && variable1
+            if method_call
               corrector.replace(node.loc.keyword, 'if')
               range = method_call.loc.expression
             else