rubocop-rails 2.12.4 → 2.13.0

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Since Rails 5.0 the default for `belongs_to` is `optional: false`
+      # unless `config.active_record.belongs_to_required_by_default` is
+      # explicitly set to `false`. The presence validator is added
+      # automatically, and explicit presence validation is redundant.
+      #
+      # @example
+      #   # bad
+      #   belongs_to :user
+      #   validates :user, presence: true
+      #
+      #   # bad
+      #   belongs_to :user
+      #   validates :user_id, presence: true
+      #
+      #   # bad
+      #   belongs_to :author, foreign_key: :user_id
+      #   validates :user_id, presence: true
+      #
+      #   # good
+      #   belongs_to :user
+      #
+      #   # good
+      #   belongs_to :author, foreign_key: :user_id
+      #
+      class RedundantPresenceValidationOnBelongsTo < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Remove explicit presence validation for `%<association>s`.'
+        RESTRICT_ON_SEND = %i[validates].freeze
+
+        minimum_target_rails_version 5.0
+
+        # @!method presence_validation?(node)
+        #   Match a `validates` statement with a presence check
+        #
+        #   @example source that matches - by association
+        #     validates :user, presence: true
+        #
+        #   @example source that matches - with presence options
+        #     validates :user, presence: { message: 'duplicate' }
+        #
+        #   @example source that matches - by a foreign key
+        #     validates :user_id, presence: true
+        def_node_matcher :presence_validation?, <<~PATTERN
+          $(
+            send nil? :validates
+            (sym $_)
+            ...
+            $(hash <$(pair (sym :presence) {true hash}) ...>)
+          )
+        PATTERN
+
+        # @!method optional_option?(node)
+        #  Match a `belongs_to` association with an optional option in a hash
+        def_node_matcher :optional?, <<~PATTERN
+          (send nil? :belongs_to _ ... #optional_option?)
+        PATTERN
+
+        # @!method optional_option?(node)
+        #  Match an optional option in a hash
+        def_node_matcher :optional_option?, <<~PATTERN
+          {
+            (hash <(pair (sym :optional) true) ...>)   # optional: true
+            (hash <(pair (sym :required) false) ...>)  # required: false
+          }
+        PATTERN
+
+        # @!method any_belongs_to?(node, association:)
+        #   Match a class with `belongs_to` with no regard to `foreign_key` option
+        #
+        #   @example source that matches
+        #     belongs_to :user
+        #
+        #   @example source that matches - regardless of `foreign_key`
+        #     belongs_to :author, foreign_key: :user_id
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @param association [Symbol]
+        #   @return [Array<RuboCop::AST::Node>, nil] matching node
+        def_node_matcher :any_belongs_to?, <<~PATTERN
+          (begin
+            <
+              $(send nil? :belongs_to (sym %association) ...)
+              ...
+            >
+          )
+        PATTERN
+
+        # @!method belongs_to?(node, key:, fk:)
+        #   Match a class with a matching association, either by name or an explicit
+        #   `foreign_key` option
+        #
+        #   @example source that matches - fk matches `foreign_key` option
+        #     belongs_to :author, foreign_key: :user_id
+        #
+        #   @example source that matches - key matches association name
+        #     belongs_to :user
+        #
+        #   @example source that does not match - explicit `foreign_key` does not match
+        #     belongs_to :user, foreign_key: :account_id
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @param key [Symbol] e.g. `:user`
+        #   @param fk [Symbol] e.g. `:user_id`
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :belongs_to?, <<~PATTERN
+          (begin
+            <
+              ${
+                #belongs_to_without_fk?(%key)         # belongs_to :user
+                #belongs_to_with_a_matching_fk?(%fk)  # belongs_to :author, foreign_key: :user_id
+              }
+              ...
+            >
+          )
+        PATTERN
+
+        # @!method belongs_to_without_fk?(node, fk)
+        #   Match a matching `belongs_to` association, without an explicit `foreign_key` option
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @param key [Symbol] e.g. `:user`
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :belongs_to_without_fk?, <<~PATTERN
+          {
+            (send nil? :belongs_to (sym %1))        # belongs_to :user
+            (send nil? :belongs_to (sym %1) !hash)  # belongs_to :user, -> { not_deleted }
+            (send nil? :belongs_to (sym %1) !(hash <(pair (sym :foreign_key) _) ...>))
+          }
+        PATTERN
+
+        # @!method belongs_to_with_a_matching_fk?(node, fk)
+        #   Match a matching `belongs_to` association with a matching explicit `foreign_key` option
+        #
+        #   @example source that matches
+        #     belongs_to :author, foreign_key: :user_id
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @param fk [Symbol] e.g. `:user_id`
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :belongs_to_with_a_matching_fk?, <<~PATTERN
+          (send nil? :belongs_to ... (hash <(pair (sym :foreign_key) (sym %1)) ...>))
+        PATTERN
+
+        def on_send(node)
+          validation, key, options, presence = presence_validation?(node)
+          return unless validation
+
+          belongs_to = belongs_to_for(node.parent, key)
+          return unless belongs_to
+          return if optional?(belongs_to)
+
+          message = format(MSG, association: key.to_s)
+
+          add_offense(presence, message: message) do |corrector|
+            remove_presence_validation(corrector, node, options, presence)
+          end
+        end
+
+        private
+
+        def belongs_to_for(model_class_node, key)
+          if key.to_s.end_with?('_id')
+            normalized_key = key.to_s.delete_suffix('_id').to_sym
+            belongs_to?(model_class_node, key: normalized_key, fk: key)
+          else
+            any_belongs_to?(model_class_node, association: key)
+          end
+        end
+
+        def remove_presence_validation(corrector, node, options, presence)
+          if options.children.one?
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+          else
+            range = range_with_surrounding_comma(
+              range_with_surrounding_space(range: presence.source_range, side: :left),
+              :left
+            )
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,8 +5,10 @@ module RuboCop
     module Rails
       # This cop checks if the value of the option `class_name`, in
       # the definition of a reflection is a string.
-      # It is marked as unsafe because it cannot be determined whether
-      # constant or method return value specified to `class_name` is a string.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be determined whether
+      #   constant or method return value specified to `class_name` is a string.
       #
       # @example
       #   # bad

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop checks whether constant value isn't relative date.
       # Because the relative date will be evaluated only once.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because its dependence on the constant is not corrected.
+      #
       # @example
       #   # bad
       #   class SomeClass

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

@@ -179,7 +179,7 @@ module RuboCop
         MSG = '%<action>s is not reversible.'
 
         def_node_matcher :irreversible_schema_statement_call, <<~PATTERN
-          (send nil? ${:execute :remove_belongs_to} ...)
+          (send nil? ${:change_column :execute :remove_belongs_to :remove_reference} ...)
         PATTERN
 
         def_node_matcher :drop_table_call, <<~PATTERN

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Use a single `#join` instead of chaining on `Rails.root` or `Rails.public_path`.
+      #
+      # @example
+      #   # bad
+      #   Rails.root.join('db').join('schema.rb')
+      #   Rails.root.join('db').join(migrate).join('migration.rb')
+      #   Rails.public_path.join('path').join('file.pdf')
+      #   Rails.public_path.join('path').join(to).join('file.pdf')
+      #
+      #   # good
+      #   Rails.root.join('db', 'schema.rb')
+      #   Rails.root.join('db', migrate, 'migration.rb')
+      #   Rails.public_path.join('path', 'file.pdf')
+      #   Rails.public_path.join('path', to, 'file.pdf')
+      #
+      class RootJoinChain < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `%<root>s.join(...)` instead of chaining `#join` calls.'
+
+        RESTRICT_ON_SEND = %i[join].to_set.freeze
+
+        # @!method rails_root?(node)
+        def_node_matcher :rails_root?, <<~PATTERN
+          (send (const {nil? cbase} :Rails) {:root :public_path})
+        PATTERN
+
+        # @!method join?(node)
+        def_node_matcher :join?, <<~PATTERN
+          (send _ :join $...)
+        PATTERN
+
+        def on_send(node)
+          evidence(node) do |rails_node, args|
+            add_offense(node, message: format(MSG, root: rails_node.source)) do |corrector|
+              range = range_between(rails_node.loc.selector.end_pos, node.loc.expression.end_pos)
+              replacement = ".join(#{args.map(&:source).join(', ')})"
+
+              corrector.replace(range, replacement)
+            end
+          end
+        end
+
+        private
+
+        def evidence(node)
+          # Are we at the *end* of the join chain?
+          return if join?(node.parent)
+          # Is there only one join?
+          return if rails_root?(node.receiver)
+
+          all_args = []
+
+          while (args = join?(node))
+            all_args = args + all_args
+            node = node.receiver
+          end
+
+          rails_root?(node) do
+            yield(node, all_args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,9 +6,18 @@ module RuboCop
       # This cop checks to make sure safe navigation isn't used with `blank?` in
       # a conditional.
       #
-      # While the safe navigation operator is generally a good idea, when
-      # checking `foo&.blank?` in a conditional, `foo` being `nil` will actually
-      # do the opposite of what the author intends.
+      # @safety
+      #   While the safe navigation operator is generally a good idea, when
+      #   checking `foo&.blank?` in a conditional, `foo` being `nil` will actually
+      #   do the opposite of what the author intends.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   foo&.blank? #=> nil
+      #   foo.blank? #=> true
+      #   ----
       #
       # @example
       #   # bad

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

@@ -25,6 +25,25 @@ module RuboCop
       # You can permit receivers that are giving false positives with
       # `AllowedReceivers: []`
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because a custom `update` method call would be changed to `update!`,
+      #   but the method name in the definition would be unchanged.
+      #
+      #   [source,ruby]
+      #   ----
+      #   # Original code
+      #   def update_attributes
+      #   end
+      #
+      #   update_attributes
+      #
+      #   # After running rubocop --safe-auto-correct
+      #   def update_attributes
+      #   end
+      #
+      #   update
+      #   ----
+      #
       # @example
       #
       #   # bad

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces the use of the `comment` option when adding a new table or column
+      # to the database during a migration.
+      #
+      # @example
+      #   # bad (no comment for a new column or table)
+      #   add_column :table, :column, :integer
+      #
+      #   create_table :table do |t|
+      #     t.type :column
+      #   end
+      #
+      #   # good
+      #   add_column :table, :column, :integer, comment: 'Number of offenses'
+      #
+      #   create_table :table, comment: 'Table of offenses data' do |t|
+      #     t.type :column, comment: 'Number of offenses'
+      #   end
+      #
+      class SchemaComment < Base
+        include ActiveRecordMigrationsHelper
+
+        COLUMN_MSG = 'New database column without `comment`.'
+        TABLE_MSG = 'New database table without `comment`.'
+        RESTRICT_ON_SEND = %i[add_column create_table].freeze
+        CREATE_TABLE_COLUMN_METHODS = Set[
+          *(
+            RAILS_ABSTRACT_SCHEMA_DEFINITIONS |
+            RAILS_ABSTRACT_SCHEMA_DEFINITIONS_HELPERS |
+            POSTGRES_SCHEMA_DEFINITIONS |
+            MYSQL_SCHEMA_DEFINITIONS
+          )
+        ].freeze
+
+        # @!method comment_present?(node)
+        def_node_matcher :comment_present?, <<~PATTERN
+          (hash <(pair {(sym :comment) (str "comment")} (_ [present?])) ...>)
+        PATTERN
+
+        # @!method add_column?(node)
+        def_node_matcher :add_column?, <<~PATTERN
+          (send nil? :add_column _table _column _type _?)
+        PATTERN
+
+        # @!method add_column_with_comment?(node)
+        def_node_matcher :add_column_with_comment?, <<~PATTERN
+          (send nil? :add_column _table _column _type #comment_present?)
+        PATTERN
+
+        # @!method create_table?(node)
+        def_node_matcher :create_table?, <<~PATTERN
+          (send nil? :create_table _table _?)
+        PATTERN
+
+        # @!method create_table?(node)
+        def_node_matcher :create_table_with_comment?, <<~PATTERN
+          (send nil? :create_table _table #comment_present? ...)
+        PATTERN
+
+        # @!method t_column?(node)
+        def_node_matcher :t_column?, <<~PATTERN
+          (send _var CREATE_TABLE_COLUMN_METHODS ...)
+        PATTERN
+
+        # @!method t_column_with_comment?(node)
+        def_node_matcher :t_column_with_comment?, <<~PATTERN
+          (send _var CREATE_TABLE_COLUMN_METHODS _column _type? #comment_present?)
+        PATTERN
+
+        def on_send(node)
+          if add_column_without_comment?(node)
+            add_offense(node, message: COLUMN_MSG)
+          elsif create_table?(node)
+            if create_table_without_comment?(node)
+              add_offense(node, message: TABLE_MSG)
+            elsif create_table_column_call_without_comment?(node)
+              add_offense(node.parent.body, message: COLUMN_MSG)
+            end
+          end
+        end
+
+        private
+
+        def add_column_without_comment?(node)
+          add_column?(node) && !add_column_with_comment?(node)
+        end
+
+        def create_table_without_comment?(node)
+          create_table?(node) && !create_table_with_comment?(node)
+        end
+
+        def create_table_column_call_without_comment?(node)
+          create_table_with_block?(node.parent) &&
+            t_column?(node.parent.body) &&
+            !t_column_with_comment?(node.parent.body)
+        end
+      end
+    end
+  end
+end

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

@@ -5,8 +5,10 @@ module RuboCop
     module Rails
       #
       # Checks SQL heredocs to use `.squish`.
-      # Some SQL syntax (e.g. PostgreSQL comments and functions) requires newlines
-      # to be preserved in order to work, thus auto-correction for this cop is not safe.
+      #
+      # @safety
+      #   Some SQL syntax (e.g. PostgreSQL comments and functions) requires newlines
+      #   to be preserved in order to work, thus auto-correction for this cop is not safe.
       #
       # @example
       #   # bad

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

@@ -14,6 +14,9 @@ module RuboCop
       # When EnforcedStyle is 'flexible' then it's also allowed
       # to use `Time#in_time_zone`.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may change handling time.
+      #
       # @example
       #   # bad
       #   Time.now

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

@@ -3,47 +3,46 @@
 module RuboCop
   module Cop
     module Rails
-      # Prefer the use of distinct, before pluck instead of after.
+      # Prefer using `distinct` before `pluck` instead of `uniq` after `pluck`.
       #
-      # The use of distinct before pluck is preferred because it executes within
+      # The use of distinct before pluck is preferred because it executes by
       # the database.
       #
       # This cop has two different enforcement modes. When the EnforcedStyle
-      # is conservative (the default) then only calls to pluck on a constant
-      # (i.e. a model class) before distinct are added as offenses.
+      # is `conservative` (the default), then only calls to `pluck` on a constant
+      # (i.e. a model class) before `uniq` are added as offenses.
       #
-      # When the EnforcedStyle is aggressive then all calls to pluck before
+      # When the EnforcedStyle is `aggressive` then all calls to `pluck` before
       # distinct are added as offenses. This may lead to false positives
-      # as the cop cannot distinguish between calls to pluck on an
+      # as the cop cannot distinguish between calls to `pluck` on an
       # ActiveRecord::Relation vs a call to pluck on an
       # ActiveRecord::Associations::CollectionProxy.
       #
-      # This cop is unsafe because the behavior may change depending on the
-      # database collation.
-      # Autocorrect is disabled by default for this cop since it may generate
-      # false positives.
+      # @safety
+      #   This cop is unsafe for autocorrection because the behavior may change
+      #   depending on the database collation.
       #
       # @example EnforcedStyle: conservative (default)
-      #   # bad
-      #   Model.pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   Album.pluck(:band_name).uniq
       #
       #   # good
-      #   Model.distinct.pluck(:id)
+      #   Album.distinct.pluck(:band_name)
       #
       # @example EnforcedStyle: aggressive
-      #   # bad
-      #   # this will return a Relation that pluck is called on
-      #   Model.where(cond: true).pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   Album.pluck(:band_name).uniq
       #
-      #   # bad
-      #   # an association on an instance will return a CollectionProxy
-      #   instance.assoc.pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   Album.where(year: 1985).pluck(:band_name).uniq
       #
-      #   # bad
-      #   Model.pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   customer.favourites.pluck(:color).uniq
       #
       #   # good
-      #   Model.distinct.pluck(:id)
+      #   Album.distinct.pluck(:band_name)
+      #   Album.distinct.where(year: 1985).pluck(:band_name)
+      #   customer.favourites.distinct.pluck(:color)
       #
       class UniqBeforePluck < Base
         include ConfigurableEnforcedStyle
@@ -51,10 +50,9 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `distinct` before `pluck`.'
-        RESTRICT_ON_SEND = %i[uniq distinct pluck].freeze
+        RESTRICT_ON_SEND = %i[uniq].freeze
         NEWLINE = "\n"
-        PATTERN = '[!^block (send (send %<type>s :pluck ...) ' \
-                  '${:uniq :distinct} ...)]'
+        PATTERN = '[!^block (send (send %<type>s :pluck ...) :uniq ...)]'
 
         def_node_matcher :conservative_node_match,
                          format(PATTERN, type: 'const')
@@ -63,13 +61,13 @@ module RuboCop
                          format(PATTERN, type: '_')
 
         def on_send(node)
-          method = if style == :conservative
-                     conservative_node_match(node)
-                   else
-                     aggressive_node_match(node)
-                   end
+          uniq = if style == :conservative
+                   conservative_node_match(node)
+                 else
+                   aggressive_node_match(node)
+                 end
 
-          return unless method
+          return unless uniq
 
           add_offense(node.loc.selector) do |corrector|
             method = node.method_name
@@ -81,10 +79,6 @@ module RuboCop
 
         private
 
-        def style_parameter_name
-          'EnforcedStyle'
-        end
-
         def dot_method_with_whitespace(method, node)
           range_between(dot_method_begin_pos(method, node),
                         node.loc.selector.end_pos)

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop identifies places where manually constructed SQL
       # in `where` can be replaced with `where(attribute: value)`.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because is may change SQL.
+      #   See: https://github.com/rubocop/rubocop-rails/issues/403
+      #
       # @example
       #   # bad
       #   User.where('name = ?', 'Gabe')

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

@@ -11,16 +11,17 @@ module RuboCop
       # When EnforcedStyle is 'where' then the cop enforces
       # `where(...).exists?` over `exists?(...)`.
       #
-      # This cop is unsafe for auto-correction because the behavior may change on the following case:
+      # @safety
+      #   This cop is unsafe for auto-correction because the behavior may change on the following case:
       #
-      # [source,ruby]
-      # ----
-      # Author.includes(:articles).where(articles: {id: id}).exists?
-      # #=> Perform `eager_load` behavior (`LEFT JOIN` query) and get result.
+      #   [source,ruby]
+      #   ----
+      #   Author.includes(:articles).where(articles: {id: id}).exists?
+      #   #=> Perform `eager_load` behavior (`LEFT JOIN` query) and get result.
       #
-      # Author.includes(:articles).exists?(articles: {id: id})
-      # #=> Perform `preload` behavior and `ActiveRecord::StatementInvalid` error occurs.
-      # ----
+      #   Author.includes(:articles).exists?(articles: {id: id})
+      #   #=> Perform `preload` behavior and `ActiveRecord::StatementInvalid` error occurs.
+      #   ----
       #
       # @example EnforcedStyle: exists (default)
       #   # bad

data/lib/rubocop/cop/rails_cops.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'mixin/active_record_helper'
+require_relative 'mixin/active_record_migrations_helper'
 require_relative 'mixin/enforce_superclass'
 require_relative 'mixin/index_method'
 require_relative 'mixin/target_rails_version'
@@ -22,12 +23,14 @@ require_relative 'rails/attribute_default_block_value'
 require_relative 'rails/belongs_to'
 require_relative 'rails/blank'
 require_relative 'rails/bulk_change_table'
+require_relative 'rails/compact_blank'
 require_relative 'rails/content_tag'
 require_relative 'rails/create_table_with_timestamps'
 require_relative 'rails/date'
 require_relative 'rails/default_scope'
 require_relative 'rails/delegate'
 require_relative 'rails/delegate_allow_blank'
+require_relative 'rails/duration_arithmetic'
 require_relative 'rails/dynamic_find_by'
 require_relative 'rails/eager_evaluation_log_message'
 require_relative 'rails/enum_hash'
@@ -71,6 +74,7 @@ require_relative 'rails/rake_environment'
 require_relative 'rails/read_write_attribute'
 require_relative 'rails/redundant_allow_nil'
 require_relative 'rails/redundant_foreign_key'
+require_relative 'rails/redundant_presence_validation_on_belongs_to'
 require_relative 'rails/redundant_receiver_in_with_options'
 require_relative 'rails/redundant_travel_back'
 require_relative 'rails/reflection_class_name'
@@ -82,9 +86,11 @@ require_relative 'rails/request_referer'
 require_relative 'rails/require_dependency'
 require_relative 'rails/reversible_migration'
 require_relative 'rails/reversible_migration_method_definition'
+require_relative 'rails/root_join_chain'
 require_relative 'rails/safe_navigation'
 require_relative 'rails/safe_navigation_with_blank'
 require_relative 'rails/save_bang'
+require_relative 'rails/schema_comment'
 require_relative 'rails/scope_args'
 require_relative 'rails/short_i18n'
 require_relative 'rails/skips_model_validations'