rubocop-rails 2.11.2 → 2.19.1

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

@@ -3,21 +3,21 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that `tag` is used instead of `content_tag`
-      # because `content_tag` is legacy syntax.
+      # Checks legacy syntax usage of `tag`
       #
-      # NOTE: Allow `content_tag` when the first argument is a variable because
-      #      `content_tag(name)` is simpler rather than `tag.public_send(name)`.
+      # NOTE: Allow `tag` when the first argument is a variable because
+      # `tag(name)` is simpler rather than `tag.public_send(name)`.
+      # And this cop will be renamed to something like `LegacyTag` in the future. (e.g. RuboCop Rails 2.0)
       #
       # @example
       #  # bad
-      #  content_tag(:p, 'Hello world!')
-      #  content_tag(:br)
+      #  tag(:p)
+      #  tag(:br, class: 'classname')
       #
       #  # good
-      #  tag.p('Hello world!')
-      #  tag.br
-      #  content_tag(name, 'Hello world!')
+      #  tag.p
+      #  tag.br(class: 'classname')
+      #  tag(name, class: 'classname')
       class ContentTag < Base
         include RangeHelp
         extend AutoCorrector
@@ -25,25 +25,24 @@ module RuboCop
 
         minimum_target_rails_version 5.1
 
-        MSG = 'Use `tag` instead of `content_tag`.'
-        RESTRICT_ON_SEND = %i[content_tag].freeze
+        MSG = 'Use `tag.%<preferred_method>s` instead of `tag(%<current_argument>s)`.'
+        RESTRICT_ON_SEND = %i[tag].freeze
 
         def on_new_investigation
           @corrected_nodes = nil
         end
 
         def on_send(node)
+          return unless node.receiver.nil?
+          return if node.arguments.count >= 3
+
           first_argument = node.first_argument
-          return if !first_argument ||
-                    allowed_argument?(first_argument) ||
-                    corrected_ancestor?(node)
+          return if !first_argument || allowed_argument?(first_argument) || corrected_ancestor?(node)
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
+          preferred_method = node.first_argument.value.to_s.underscore
+          message = format(MSG, preferred_method: preferred_method, current_argument: first_argument.source)
 
-            @corrected_nodes ||= Set.new.compare_by_identity
-            @corrected_nodes.add(node)
-          end
+          register_offense(node, message, preferred_method)
         end
 
         private
@@ -53,30 +52,40 @@ module RuboCop
         end
 
         def allowed_argument?(argument)
-          argument.variable? || argument.send_type? || argument.const_type? || argument.splat_type?
+          argument.variable? ||
+            argument.send_type? ||
+            argument.const_type? ||
+            argument.splat_type? ||
+            allowed_name?(argument) ||
+            !argument.respond_to?(:value)
         end
 
-        def autocorrect(corrector, node)
-          if method_name?(node.first_argument)
-            range = correction_range(node)
-
-            rest_args = node.arguments.drop(1)
-            replacement = "tag.#{node.first_argument.value.to_s.underscore}(#{rest_args.map(&:source).join(', ')})"
+        def register_offense(node, message, preferred_method)
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node, preferred_method)
 
-            corrector.replace(range, replacement)
-          else
-            corrector.replace(node.loc.selector, 'tag')
+            @corrected_nodes ||= Set.new.compare_by_identity
+            @corrected_nodes.add(node)
           end
         end
 
-        def method_name?(node)
-          return false unless node.str_type? || node.sym_type?
+        def autocorrect(corrector, node, preferred_method)
+          range = correction_range(node)
+
+          rest_args = node.arguments.drop(1)
+          replacement = "tag.#{preferred_method}(#{rest_args.map(&:source).join(', ')})"
+
+          corrector.replace(range, replacement)
+        end
+
+        def allowed_name?(argument)
+          return false unless argument.str_type? || argument.sym_type?
 
-          /^[a-zA-Z_][a-zA-Z_\-0-9]*$/.match?(node.value)
+          !/^[a-zA-Z-][a-zA-Z\-0-9]*$/.match?(argument.value)
         end
 
         def correction_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
       end
     end

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

@@ -3,10 +3,12 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks the migration for which timestamps are not included
-      # when creating a new table.
+      # Checks the migration for which timestamps are not included when creating a new table.
       # In many cases, timestamps are useful information and should be added.
       #
+      # NOTE: Allow `timestamps` not written when `id: false` because this emphasizes respecting
+      # user's editing intentions.
+      #
       # @example
       #   # bad
       #   create_table :users
@@ -40,15 +42,21 @@ module RuboCop
       #
       #     t.datetime :updated_at, default: -> { 'CURRENT_TIMESTAMP' }
       #   end
+      #
+      #   # good
+      #   create_table :users, articles, id: false do |t|
+      #     t.integer :user_id
+      #     t.integer :article_id
+      #   end
+      #
       class CreateTableWithTimestamps < Base
+        include ActiveRecordMigrationsHelper
+
         MSG = 'Add timestamps when creating a new table.'
         RESTRICT_ON_SEND = %i[create_table].freeze
 
-        def_node_matcher :create_table_with_block?, <<~PATTERN
-          (block
-            (send nil? :create_table ...)
-            (args (arg _var))
-            _)
+        def_node_search :use_id_false_option?, <<~PATTERN
+          (pair (sym :id) (false))
         PATTERN
 
         def_node_matcher :create_table_with_timestamps_proc?, <<~PATTERN
@@ -66,7 +74,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.command?(:create_table)
+          return if !node.command?(:create_table) || use_id_false_option?(node)
 
           parent = node.parent
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the correct use of Date methods,
+      # Checks for the correct use of Date methods,
       # such as Date.today, Date.current etc.
       #
       # Using `Date.today` is dangerous, because it doesn't know anything about
@@ -22,26 +22,26 @@ module RuboCop
       # And you can set a warning for `to_time` with `AllowToTime: false`.
       # `AllowToTime` is `true` by default to prevent false positive on `DateTime` object.
       #
-      # @example EnforcedStyle: strict
+      # @example EnforcedStyle: flexible (default)
       #   # bad
-      #   Date.current
-      #   Date.yesterday
       #   Date.today
       #
       #   # good
       #   Time.zone.today
       #   Time.zone.today - 1.day
+      #   Date.current
+      #   Date.yesterday
+      #   date.in_time_zone
       #
-      # @example EnforcedStyle: flexible (default)
+      # @example EnforcedStyle: strict
       #   # bad
+      #   Date.current
+      #   Date.yesterday
       #   Date.today
       #
       #   # good
       #   Time.zone.today
       #   Time.zone.today - 1.day
-      #   Date.current
-      #   Date.yesterday
-      #   date.in_time_zone
       #
       # @example AllowToTime: true (default)
       #   # good
@@ -53,22 +53,17 @@ module RuboCop
       class Date < Base
         include ConfigurableEnforcedStyle
 
-        MSG = 'Do not use `Date.%<method_called>s` without zone. Use ' \
-              '`Time.zone.%<day>s` instead.'
+        MSG = 'Do not use `Date.%<method_called>s` without zone. Use `Time.zone.%<day>s` instead.'
 
-        MSG_SEND = 'Do not use `%<method>s` on Date objects, because they ' \
-                   'know nothing about the time zone in use.'
+        MSG_SEND = 'Do not use `%<method>s` on Date objects, because they know nothing about the time zone in use.'
 
         RESTRICT_ON_SEND = %i[to_time to_time_in_current_zone].freeze
 
         BAD_DAYS = %i[today current yesterday tomorrow].freeze
 
-        DEPRECATED_METHODS = [
-          { deprecated: 'to_time_in_current_zone', relevant: 'in_time_zone' }
-        ].freeze
+        DEPRECATED_METHODS = [{ deprecated: 'to_time_in_current_zone', relevant: 'in_time_zone' }].freeze
 
-        DEPRECATED_MSG = '`%<deprecated>s` is deprecated. ' \
-                         'Use `%<relevant>s` instead.'
+        DEPRECATED_MSG = '`%<deprecated>s` is deprecated. Use `%<relevant>s` instead.'
 
         def on_const(node)
           mod, klass = *node.children

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for uses of `default_scope`.
+      # Looks for uses of `default_scope`.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for delegations that could have been created
+      # Looks for delegations that could have been created
       # automatically with the `delegate` method.
       #
       # Safe navigation `&.` is ignored because Rails' `allow_nil`
@@ -24,6 +24,14 @@ module RuboCop
       #   # good
       #   delegate :bar, to: :foo
       #
+      #   # bad
+      #   def bar
+      #     self.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :self
+      #
       #   # good
       #   def bar
       #     foo&.bar
@@ -54,12 +62,13 @@ module RuboCop
       #   delegate :bar, to: :foo, prefix: true
       class Delegate < Base
         extend AutoCorrector
+        include VisibilityHelp
 
         MSG = 'Use `delegate` to define delegations.'
 
         def_node_matcher :delegate?, <<~PATTERN
           (def _method_name _args
-            (send (send nil? _) _ ...))
+            (send {(send nil? _) (self)} _ ...))
         PATTERN
 
         def on_def(node)
@@ -73,10 +82,14 @@ module RuboCop
 
         def register_offense(node)
           add_offense(node.loc.keyword) do |corrector|
-            delegation = ["delegate :#{node.body.method_name}", "to: :#{node.body.receiver.method_name}"]
+            body = node.body
+
+            receiver = body.receiver.self_type? ? 'self' : ":#{body.receiver.method_name}"
+
+            delegation = ["delegate :#{body.method_name}", "to: #{receiver}"]
             delegation << ['prefix: true'] if node.method?(prefixed_method_name(node.body))
 
-            corrector.replace(node.source_range, delegation.join(', '))
+            corrector.replace(node, delegation.join(', '))
           end
         end
 
@@ -92,15 +105,12 @@ module RuboCop
           return false if arg_array.size != argument_array.size
 
           arg_array.zip(argument_array).all? do |arg, argument|
-            arg.arg_type? &&
-              argument.lvar_type? &&
-              arg.children == argument.children
+            arg.arg_type? && argument.lvar_type? && arg.children == argument.children
           end
         end
 
         def method_name_matches?(method_name, body)
-          method_name == body.method_name ||
-            include_prefix_case? && method_name == prefixed_method_name(body)
+          method_name == body.method_name || (include_prefix_case? && method_name == prefixed_method_name(body))
         end
 
         def include_prefix_case?
@@ -108,21 +118,17 @@ module RuboCop
         end
 
         def prefixed_method_name(body)
+          return '' if body.receiver.self_type?
+
           [body.receiver.method_name, body.method_name].join('_').to_sym
         end
 
         def private_or_protected_delegation(node)
-          line = node.first_line
-          private_or_protected_before(line) ||
-            private_or_protected_inline(line)
-        end
-
-        def private_or_protected_before(line)
-          (processed_source[0..line].map(&:strip) & %w[private protected]).any?
+          private_or_protected_inline(node) || node_visibility(node) != :public
         end
 
-        def private_or_protected_inline(line)
-          processed_source[line - 1].strip.match?(/\A(private )|(protected )/)
+        def private_or_protected_inline(node)
+          processed_source[node.first_line - 1].strip.match?(/\A(private )|(protected )/)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for delegations that pass :allow_blank as an option
+      # Looks for delegations that pass :allow_blank as an option
       # instead of :allow_nil. :allow_blank is not a valid option to pass
       # to ActiveSupport#delegate.
       #
@@ -27,7 +27,7 @@ module RuboCop
           return unless (offending_node = allow_blank_option(node))
 
           add_offense(offending_node) do |corrector|
-            corrector.replace(offending_node.key.source_range, 'allow_nil')
+            corrector.replace(offending_node.key, 'allow_nil')
           end
         end
       end

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks direct manipulation of ActiveModel#errors as hash.
+      # These operations are deprecated in Rails 6.1 and will not work in Rails 7.
+      #
+      # @safety
+      #   This cop is unsafe because it can report `errors` manipulation on non-ActiveModel,
+      #   which is obviously valid.
+      #   The cop has no way of knowing whether a variable is an ActiveModel or not.
+      #
+      # @example
+      #   # bad
+      #   user.errors[:name] << 'msg'
+      #   user.errors.messages[:name] << 'msg'
+      #
+      #   # good
+      #   user.errors.add(:name, 'msg')
+      #
+      #   # bad
+      #   user.errors[:name].clear
+      #   user.errors.messages[:name].clear
+      #
+      #   # good
+      #   user.errors.delete(:name)
+      #
+      #   # bad
+      #   user.errors.keys.include?(:attr)
+      #
+      #   # good
+      #   user.errors.attribute_names.include?(:attr)
+      #
+      class DeprecatedActiveModelErrorsMethods < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Avoid manipulating ActiveModel errors as hash directly.'
+        AUTOCORRECTABLE_METHODS = %i[<< clear keys].freeze
+        INCOMPATIBLE_METHODS = %i[keys values to_h to_xml].freeze
+
+        MANIPULATIVE_METHODS = Set[
+          *%i[
+            << append clear collect! compact! concat
+            delete delete_at delete_if drop drop_while fill filter! keep_if
+            flatten! insert map! pop prepend push reject! replace reverse!
+            rotate! select! shift shuffle! slice! sort! sort_by! uniq! unshift
+          ]
+        ].freeze
+
+        def_node_matcher :receiver_matcher_outside_model, '{send ivar lvar}'
+        def_node_matcher :receiver_matcher_inside_model, '{nil? send ivar lvar}'
+
+        def_node_matcher :any_manipulation?, <<~PATTERN
+          {
+            #root_manipulation?
+            #root_assignment?
+            #errors_deprecated?
+            #messages_details_manipulation?
+            #messages_details_assignment?
+          }
+        PATTERN
+
+        def_node_matcher :root_manipulation?, <<~PATTERN
+          (send
+            (send
+              (send #receiver_matcher :errors) :[] ...)
+            MANIPULATIVE_METHODS
+            ...
+          )
+        PATTERN
+
+        def_node_matcher :root_assignment?, <<~PATTERN
+          (send
+            (send #receiver_matcher :errors)
+            :[]=
+            ...)
+        PATTERN
+
+        def_node_matcher :errors_deprecated?, <<~PATTERN
+          (send
+            (send #receiver_matcher :errors)
+            {:keys :values :to_h :to_xml})
+        PATTERN
+
+        def_node_matcher :messages_details_manipulation?, <<~PATTERN
+          (send
+            (send
+              (send
+                (send #receiver_matcher :errors)
+                {:messages :details})
+                :[]
+                ...)
+              MANIPULATIVE_METHODS
+            ...)
+        PATTERN
+
+        def_node_matcher :messages_details_assignment?, <<~PATTERN
+          (send
+            (send
+              (send #receiver_matcher :errors)
+              {:messages :details})
+            :[]=
+            ...)
+        PATTERN
+
+        def on_send(node)
+          any_manipulation?(node) do
+            next if target_rails_version <= 6.0 && INCOMPATIBLE_METHODS.include?(node.method_name)
+
+            add_offense(node) do |corrector|
+              next if skip_autocorrect?(node)
+
+              autocorrect(corrector, node)
+            end
+          end
+        end
+
+        private
+
+        def skip_autocorrect?(node)
+          return true unless AUTOCORRECTABLE_METHODS.include?(node.method_name)
+          return false unless (receiver = node.receiver.receiver)
+
+          receiver.send_type? && receiver.method?(:details) && node.method?(:<<)
+        end
+
+        def autocorrect(corrector, node)
+          receiver = node.receiver
+
+          range = offense_range(node, receiver)
+          replacement = replacement(node, receiver)
+
+          corrector.replace(range, replacement)
+        end
+
+        def offense_range(node, receiver)
+          receiver = receiver.receiver while receiver.send_type? && !receiver.method?(:errors) && receiver.receiver
+          range_between(receiver.source_range.end_pos, node.source_range.end_pos)
+        end
+
+        def replacement(node, receiver)
+          return '.attribute_names' if node.method?(:keys)
+
+          key = receiver.first_argument.source
+
+          case node.method_name
+          when :<<
+            value = node.first_argument.source
+
+            ".add(#{key}, #{value})"
+          when :clear
+            ".delete(#{key})"
+          end
+        end
+
+        def receiver_matcher(node)
+          model_file? ? receiver_matcher_inside_model(node) : receiver_matcher_outside_model(node)
+        end
+
+        def model_file?
+          processed_source.file_path.include?('/models/')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces the use of dot-separated locale keys instead of specifying the `:scope` option
+      # with an array or a single symbol in `I18n` translation methods.
+      # Dot-separated notation is easier to read and trace the hierarchy.
+      #
+      # @example
+      #   # bad
+      #   I18n.t :record_invalid, scope: [:activerecord, :errors, :messages]
+      #   I18n.t :title, scope: :invitation
+      #
+      #   # good
+      #   I18n.t 'activerecord.errors.messages.record_invalid'
+      #   I18n.t :record_invalid, scope: 'activerecord.errors.messages'
+      #
+      class DotSeparatedKeys < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use the dot-separated keys instead of specifying the `:scope` option.'
+        TRANSLATE_METHODS = %i[translate t].freeze
+
+        def_node_matcher :translate_with_scope?, <<~PATTERN
+          (send {nil? (const {nil? cbase} :I18n)} {:translate :t} ${sym_type? str_type?}
+            (hash <$(pair (sym :scope) ${array_type? sym_type?}) ...>)
+          )
+        PATTERN
+
+        def on_send(node)
+          return unless TRANSLATE_METHODS.include?(node.method_name)
+
+          translate_with_scope?(node) do |key_node, scope_node|
+            return unless should_convert_scope?(scope_node)
+
+            add_offense(scope_node) do |corrector|
+              # Eat the comma on the left.
+              range = range_with_surrounding_space(scope_node.source_range, side: :left)
+              range = range_with_surrounding_comma(range, :left)
+              corrector.remove(range)
+
+              corrector.replace(key_node, new_key(key_node, scope_node))
+            end
+          end
+        end
+
+        private
+
+        def should_convert_scope?(scope_node)
+          scopes(scope_node).all?(&:basic_literal?)
+        end
+
+        def new_key(key_node, scope_node)
+          "'#{scopes(scope_node).map(&:value).join('.')}.#{key_node.value}'".squeeze('.')
+        end
+
+        def scopes(scope_node)
+          value = scope_node.value
+
+          if value.array_type?
+            value.values
+          else
+            [value]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for associations that have been defined multiple times in the same file.
+      #
+      # When an association is defined multiple times on a model, Active Record overrides the
+      # previously defined association with the new one. Because of this, this cop's autocorrection
+      # simply keeps the last of any duplicates and discards the rest.
+      #
+      # @example
+      #
+      #   # bad
+      #   belongs_to :foo
+      #   belongs_to :bar
+      #   has_one :foo
+      #
+      #   # good
+      #   belongs_to :bar
+      #   has_one :foo
+      #
+      class DuplicateAssociation < Base
+        include RangeHelp
+        extend AutoCorrector
+        include ClassSendNodeHelper
+
+        MSG = "Association `%<name>s` is defined multiple times. Don't repeat associations."
+
+        def_node_matcher :association, <<~PATTERN
+          (send nil? {:belongs_to :has_one :has_many :has_and_belongs_to_many} ({sym str} $_) ...)
+        PATTERN
+
+        def on_class(class_node)
+          offenses(class_node).each do |name, nodes|
+            nodes.each do |node|
+              add_offense(node, message: format(MSG, name: name)) do |corrector|
+                next if same_line?(nodes.last, node)
+
+                corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+              end
+            end
+          end
+        end
+
+        private
+
+        def offenses(class_node)
+          class_send_nodes(class_node).select { |node| association(node) }
+                                      .group_by { |node| association(node).to_sym }
+                                      .select { |_, nodes| nodes.length > 1 }
+        end
+      end
+    end
+  end
+end