rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for add_column call with NOT NULL constraint
+      # in migration file.
+      #
+      # @example
+      #   # bad
+      #   add_column :users, :name, :string, null: false
+      #   add_reference :products, :category, null: false
+      #
+      #   # good
+      #   add_column :users, :name, :string, null: true
+      #   add_column :users, :name, :string, null: false, default: ''
+      #   add_reference :products, :category
+      #   add_reference :products, :category, null: false, default: 1
+      class NotNullColumn < Cop
+        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 $...))
+        PATTERN
+
+        def_node_matcher :add_not_null_reference?, <<-PATTERN
+          (send nil? :add_reference _ _ (hash $...))
+        PATTERN
+
+        def_node_matcher :null_false?, <<-PATTERN
+          (pair (sym :null) (false))
+        PATTERN
+
+        def_node_matcher :default_option?, <<-PATTERN
+          (pair (sym :default) !nil)
+        PATTERN
+
+        def on_send(node)
+          check_add_column(node)
+          check_add_reference(node)
+        end
+
+        private
+
+        def check_add_column(node)
+          pairs = add_not_null_column?(node)
+          check_pairs(pairs)
+        end
+
+        def check_add_reference(node)
+          pairs = add_not_null_reference?(node)
+          check_pairs(pairs)
+        end
+
+        def check_pairs(pairs)
+          return unless pairs
+          return if pairs.any? { |pair| default_option?(pair) }
+
+          null_false = pairs.find { |pair| null_false?(pair) }
+          return unless null_false
+
+          add_offense(null_false)
+        end
+      end
+    end
+  end
+end

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

@@ -1,28 +1,30 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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\' logger if you want to log.'.freeze
+              "Use Rails's logger if you want to log.".freeze
 
-        BLACKLIST = [:puts,
-                     :print,
-                     :p,
-                     :pp,
-                     :pretty_print,
-                     :ap].freeze
+        def_node_matcher :output?, <<-PATTERN
+          (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
+        PATTERN
 
         def on_send(node)
-          receiver, method_name, *args = *node
-          return unless receiver.nil? &&
-                        !args.empty? &&
-                        BLACKLIST.include?(method_name)
+          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

@@ -1,43 +1,91 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of output safety calls like html_safe and
-      # raw.
+      # This cop checks for the use of output safety calls like html_safe,
+      # raw, and safe_concat. These methods do not escape content. They
+      # simply return a SafeBuffer containing the content as is. Instead,
+      # use safe_join to join content and escape it and concat to
+      # concatenate content and escape it, ensuring its safety.
       #
       # @example
+      #   user_content = "<b>hi</b>"
+      #
       #   # bad
-      #   "<p>#{text}</p>".html_safe
+      #   "<p>#{user_content}</p>".html_safe
+      #   # => ActiveSupport::SafeBuffer "<p><b>hi</b></p>"
       #
       #   # good
-      #   content_tag(:p, text)
+      #   content_tag(:p, user_content)
+      #   # => ActiveSupport::SafeBuffer "<p>&lt;b&gt;hi&lt;/b&gt;</p>"
       #
       #   # bad
       #   out = ""
-      #   out << content_tag(:li, "one")
-      #   out << content_tag(:li, "two")
+      #   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>"
       #
       #   # good
       #   out = []
-      #   out << content_tag(:li, "one")
-      #   out << content_tag(:li, "two")
+      #   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>"
+      #
+      #   # bad
+      #   out = "<h1>trusted content</h1>".html_safe
+      #   out.safe_concat(user_content)
+      #   # => 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;"
+      #
+      #   # safe, though maybe not good style
+      #   out = "trusted content"
+      #   result = out.concat(user_content)
+      #   # => 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;
+      #
+      #   # bad
+      #   (user_content + " " + content_tag(:span, user_content)).html_safe
+      #   # => 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>"
       class OutputSafety < Cop
-        MSG = 'Tagging a string as html safe may be a security risk, ' \
-              'prefer `safe_join` or other Rails tag helpers instead'.freeze
+        MSG = 'Tagging a string as html safe may be a security risk.'.freeze
 
         def on_send(node)
-          receiver, method_name, *_args = *node
+          return unless looks_like_rails_html_safe?(node) ||
+                        looks_like_rails_raw?(node) ||
+                        looks_like_rails_safe_concat?(node)
+
+          add_offense(node, location: :selector)
+        end
+        alias on_csend on_send
+
+        private
+
+        def looks_like_rails_html_safe?(node)
+          node.receiver && node.method?(:html_safe) && !node.arguments?
+        end
+
+        def looks_like_rails_raw?(node)
+          node.command?(:raw) && node.arguments.one?
+        end
 
-          if receiver && method_name == :html_safe
-            add_offense(node, :selector)
-          elsif receiver.nil? && method_name == :raw
-            add_offense(node, :selector)
-          end
+        def looks_like_rails_safe_concat?(node)
+          node.method?(:safe_concat) && node.arguments.one?
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -27,45 +26,47 @@ module RuboCop
 
         PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert.freeze
 
-        MSG = 'Prefer `%s.%s`.'.freeze
+        MSG = 'Prefer `%<number>s.%<correct>s`.'.freeze
 
         def on_send(node)
-          receiver, method_name, *_args = *node
-          return unless duration_method?(method_name)
-          return unless literal_number?(receiver)
-
-          number, = *receiver
-          if expect_singular_method?(number, method_name)
-            add_offense(node,
-                        :expression,
-                        format(MSG, number, singularize(method_name)))
-          elsif expect_plural_method?(number, method_name)
-            add_offense(node,
-                        :expression,
-                        format(MSG, number, pluralize(method_name)))
-          end
-        end
+          return unless duration_method?(node.method_name)
+          return unless literal_number?(node.receiver)
 
-        private
+          return unless offense?(node)
+
+          add_offense(node)
+        end
 
         def autocorrect(node)
           lambda do |corrector|
             method_name = node.loc.selector.source
-            replacement = if plural_method?(method_name)
-                            singularize(method_name)
-                          else
-                            pluralize(method_name)
-                          end
-            corrector.replace(node.loc.selector, replacement)
+
+            corrector.replace(node.loc.selector, correct_method(method_name))
           end
         end
 
-        def expect_singular_method?(number, method_name)
-          singular_receiver?(number) && plural_method?(method_name)
+        private
+
+        def message(node)
+          number, = *node.receiver
+
+          format(MSG, number: number,
+                      correct: correct_method(node.method_name.to_s))
+        end
+
+        def correct_method(method_name)
+          if plural_method?(method_name)
+            singularize(method_name)
+          else
+            pluralize(method_name)
+          end
         end
 
-        def expect_plural_method?(number, method_name)
-          plural_receiver?(number) && singular_method?(method_name)
+        def offense?(node)
+          number, = *node.receiver
+
+          singular_receiver?(number) && plural_method?(node.method_name) ||
+            plural_receiver?(number) && singular_method?(node.method_name)
         end
 
         def plural_method?(method_name)
@@ -77,7 +78,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,118 @@
+# 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
+              $!begin
+            )
+            (if
+              (send $_recv :blank?)
+              $!begin
+              _recv
+            )
+          }
+        PATTERN
+
+        def_node_matcher :redundant_negative_receiver_and_other, <<-PATTERN
+          {
+            (if
+              (send (send $_recv :present?) :!)
+              $!begin
+              _recv
+            )
+            (if
+              (send (send $_recv :blank?) :!)
+              _recv
+              $!begin
+            )
+          }
+        PATTERN
+
+        def on_if(node)
+          redundant_receiver_and_other(node) do |receiver, other|
+            unless ignore_other_node?(other)
+              add_offense(node, message: message(node, receiver, other))
+            end
+          end
+
+          redundant_negative_receiver_and_other(node) do |receiver, other|
+            unless ignore_other_node?(other)
+              add_offense(node, message: message(node, receiver, other))
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            redundant_receiver_and_other(node) do |receiver, other|
+              corrector.replace(node.source_range, replacement(receiver, other))
+            end
+
+            redundant_negative_receiver_and_other(node) do |receiver, other|
+              corrector.replace(node.source_range, replacement(receiver, other))
+            end
+          end
+        end
+
+        private
+
+        def ignore_other_node?(node)
+          node && (node.if_type? || node.rescue_type? || node.while_type?)
+        end
+
+        def message(node, receiver, other)
+          format(MSG,
+                 prefer: replacement(receiver, other),
+                 current: node.source)
+        end
+
+        def replacement(receiver, other)
+          or_source = other.nil? || other.nil_type? ? '' : " || #{other.source}"
+          "#{receiver.source}.presence" + or_source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cops checks for code that can be changed to `blank?`.
+      # Settings:
+      #   NotNilAndNotEmpty: Convert checks for not `nil` and `not empty?`
+      #                      to `present?`
+      #   NotBlank: Convert usages of not `blank?` to `present?`
+      #   UnlessBlank: Convert usages of `unless` `blank?` to `if` `present?`
+      #
+      # @example
+      #   # NotNilAndNotEmpty: true
+      #     # bad
+      #     !foo.nil? && !foo.empty?
+      #     foo != nil && !foo.empty?
+      #     !foo.blank?
+      #
+      #     # good
+      #     foo.present?
+      #
+      #   # NotBlank: true
+      #     # bad
+      #     !foo.blank?
+      #     not foo.blank?
+      #
+      #     # good
+      #     foo.present?
+      #
+      #   # UnlessBlank: true
+      #     # bad
+      #     something unless foo.blank?
+      #
+      #     # good
+      #     something if  foo.present?
+      class Present < Cop
+        MSG_NOT_BLANK = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
+        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%<prefer>s` instead of ' \
+                                   '`%<current>s`.'.freeze
+        MSG_UNLESS_BLANK = 'Use `if %<prefer>s` instead of ' \
+                           '`%<current>s`.'.freeze
+
+        def_node_matcher :exists_and_not_empty?, <<-PATTERN
+          (and
+              {
+                (send (send $_ :nil?) :!)
+                (send (send $_ :!) :!)
+                (send $_ :!= nil)
+                $_
+              }
+              {
+                (send (send $_ :empty?) :!)
+              }
+          )
+        PATTERN
+
+        def_node_matcher :not_blank?, '(send (send $_ :blank?) :!)'
+
+        def_node_matcher :unless_blank?, <<-PATTERN
+          (:if $(send $_ :blank?) {nil? (...)} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless cop_config['NotBlank']
+
+          not_blank?(node) do |receiver|
+            add_offense(node,
+                        message: format(MSG_NOT_BLANK,
+                                        prefer: replacement(receiver),
+                                        current: node.source))
+          end
+        end
+
+        def on_and(node)
+          return unless cop_config['NotNilAndNotEmpty']
+
+          exists_and_not_empty?(node) do |variable1, variable2|
+            return unless variable1 == variable2
+
+            add_offense(node,
+                        message: format(MSG_EXISTS_AND_NOT_EMPTY,
+                                        prefer: replacement(variable1),
+                                        current: node.source))
+          end
+        end
+
+        def on_or(node)
+          return unless cop_config['NilOrEmpty']
+
+          exists_and_not_empty?(node) do |variable1, variable2|
+            return unless variable1 == variable2
+
+            add_offense(node, message: MSG_EXISTS_AND_NOT_EMPTY)
+          end
+        end
+
+        def on_if(node)
+          return unless cop_config['UnlessBlank']
+          return unless node.unless?
+
+          unless_blank?(node) do |method_call, receiver|
+            range = unless_condition(node, method_call)
+            msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver),
+                                           current: range.source)
+            add_offense(node, location: range, message: msg)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_call, variable1 = unless_blank?(node)
+
+            if method_call
+              corrector.replace(node.loc.keyword, 'if')
+              range = method_call.loc.expression
+            else
+              variable1, _variable2 =
+                exists_and_not_empty?(node) || not_blank?(node)
+              range = node.loc.expression
+            end
+
+            corrector.replace(range, replacement(variable1))
+          end
+        end
+
+        private
+
+        def unless_condition(node, method_call)
+          if node.modifier_form?
+            node.loc.keyword.join(node.loc.expression.end)
+          else
+            node.loc.expression.begin.join(method_call.loc.expression)
+          end
+        end
+
+        def replacement(node)
+          node.respond_to?(:source) ? "#{node.source}.present?" : 'present?'
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -19,29 +18,21 @@ module RuboCop
       class ReadWriteAttribute < Cop
         MSG = 'Prefer `%s` over `%s`.'.freeze
 
-        def on_send(node)
-          receiver, method_name, *_args = *node
-          return if receiver
-          return unless [:read_attribute,
-                         :write_attribute].include?(method_name)
-
-          add_offense(node, :selector)
-        end
+        def_node_matcher :read_write_attribute?, <<-PATTERN
+          {
+            (send nil? :read_attribute _)
+            (send nil? :write_attribute _ _)
+          }
+        PATTERN
 
-        def message(node)
-          _receiver, method_name, *_args = *node
+        def on_send(node)
+          return unless read_write_attribute?(node)
 
-          if method_name == :read_attribute
-            format(MSG, 'self[:attr]', 'read_attribute(:attr)')
-          else
-            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
-          end
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
-          _receiver, method_name, _body = *node
-
-          case method_name
+          case node.method_name
           when :read_attribute
             replacement = read_attribute_replacement(node)
           when :write_attribute
@@ -53,17 +44,20 @@ module RuboCop
 
         private
 
-        def read_attribute_replacement(node)
-          _receiver, _method_name, body = *node
+        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
 
-          "self[#{body.source}]"
+        def read_attribute_replacement(node)
+          "self[#{node.first_argument.source}]"
         end
 
         def write_attribute_replacement(node)
-          _receiver, _method_name, *args = *node
-          name, value = *args
-
-          "self[#{name.source}] = #{value.source}"
+          "self[#{node.first_argument.source}] = #{node.last_argument.source}"
         end
       end
     end