rubocop-rails 2.13.0 → 2.14.0

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for places where I18n "lazy" lookup can be used.
+      #
+      # @example
+      #   # en.yml
+      #   # en:
+      #   #   books:
+      #   #     create:
+      #   #       success: Book created!
+      #
+      #   # bad
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('books.create.success')
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('.success')
+      #     end
+      #   end
+      #
+      class I18nLazyLookup < Base
+        include VisibilityHelp
+        extend AutoCorrector
+
+        MSG = 'Use "lazy" lookup for the text used in controllers.'
+
+        def_node_matcher :translate_call?, <<~PATTERN
+          (send nil? {:translate :t} ${sym_type? str_type?} ...)
+        PATTERN
+
+        def on_send(node)
+          translate_call?(node) do |key_node|
+            key = key_node.value
+            return if key.to_s.start_with?('.')
+
+            controller, action = controller_and_action(node)
+            return unless controller && action
+
+            scoped_key = get_scoped_key(key_node, controller, action)
+            return unless key == scoped_key
+
+            add_offense(key_node) do |corrector|
+              unscoped_key = key_node.value.to_s.split('.').last
+              corrector.replace(key_node, "'.#{unscoped_key}'")
+            end
+          end
+        end
+
+        private
+
+        def controller_and_action(node)
+          action_node = node.each_ancestor(:def).first
+          return unless action_node && node_visibility(action_node) == :public
+
+          controller_node = node.each_ancestor(:class).first
+          return unless controller_node && controller_node.identifier.source.end_with?('Controller')
+
+          [controller_node, action_node]
+        end
+
+        def get_scoped_key(key_node, controller, action)
+          path = controller_path(controller).tr('/', '.')
+          action_name = action.method_name
+          key = key_node.value.to_s.split('.').last
+
+          "#{path}.#{action_name}.#{key}"
+        end
+
+        def controller_path(controller)
+          module_name = controller.parent_module_name
+          controller_name = controller.identifier.source
+
+          path = if module_name == 'Object'
+                   controller_name
+                 else
+                   "#{module_name}::#{controller_name}"
+                 end
+
+          path.delete_suffix('Controller').underscore
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces use of I18n and locale files instead of locale specific strings.
+      #
+      # @example
+      #   # bad
+      #   class User < ApplicationRecord
+      #     validates :email, presence: { message: "must be present" }
+      #   end
+      #
+      #   # good
+      #   # config/locales/en.yml
+      #   # en:
+      #   #   activerecord:
+      #   #     errors:
+      #   #       models:
+      #   #         user:
+      #   #           blank: "must be present"
+      #
+      #   class User < ApplicationRecord
+      #     validates :email, presence: true
+      #   end
+      #
+      #   # bad
+      #   class PostsController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to root_path, notice: "Post created!"
+      #     end
+      #   end
+      #
+      #   # good
+      #   # config/locales/en.yml
+      #   # en:
+      #   #   posts:
+      #   #     create:
+      #   #       success: "Post created!"
+      #
+      #   class PostsController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to root_path, notice: t(".success")
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class UserMailer < ApplicationMailer
+      #     def welcome(user)
+      #       mail(to: user.email, subject: "Welcome to My Awesome Site")
+      #     end
+      #   end
+      #
+      #   # good
+      #   # config/locales/en.yml
+      #   # en:
+      #   #   user_mailer:
+      #   #     welcome:
+      #   #       subject: "Welcome to My Awesome Site"
+      #
+      #   class UserMailer < ApplicationMailer
+      #     def welcome(user)
+      #       mail(to: user.email)
+      #     end
+      #   end
+      #
+      class I18nLocaleTexts < Base
+        MSG = 'Move locale texts to the locale files in the `config/locales` directory.'
+
+        RESTRICT_ON_SEND = %i[validates redirect_to []= mail].freeze
+
+        def_node_search :validation_message, <<~PATTERN
+          (pair (sym :message) $str)
+        PATTERN
+
+        def_node_search :redirect_to_flash, <<~PATTERN
+          (pair (sym {:notice :alert}) $str)
+        PATTERN
+
+        def_node_matcher :flash_assignment?, <<~PATTERN
+          (send (send nil? :flash) :[]= _ $str)
+        PATTERN
+
+        def_node_search :mail_subject, <<~PATTERN
+          (pair (sym :subject) $str)
+        PATTERN
+
+        def on_send(node)
+          case node.method_name
+          when :validates
+            validation_message(node) do |text_node|
+              add_offense(text_node)
+            end
+            return
+          when :redirect_to
+            text_node = redirect_to_flash(node).to_a.last
+          when :[]=
+            text_node = flash_assignment?(node)
+          when :mail
+            text_node = mail_subject(node).to_a.last
+          end
+
+          add_offense(text_node) if text_node
+        end
+      end
+    end
+  end
+end

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

@@ -23,22 +23,22 @@ module RuboCop
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} _ :each_with_object (hash))
+            (call _ :each_with_object (hash))
             (args (arg $_el) (arg _memo))
-            ({send csend} (lvar _memo) :[]= $!`_memo (lvar _el)))
+            (call (lvar _memo) :[]= $!`_memo (lvar _el)))
         PATTERN
 
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            ({send csend} _ :to_h)
+            (call _ :to_h)
             (args (arg $_el))
             (array $_ (lvar _el)))
         PATTERN
 
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
-          ({send csend}
+          (call
             (block
-              ({send csend} _ {:map :collect})
+              (call _ {:map :collect})
               (args (arg $_el))
               (array $_ (lvar _el)))
             :to_h)
@@ -49,7 +49,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              ({send csend} _ {:map :collect})
+              (call _ {:map :collect})
               (args (arg $_el))
               (array $_ (lvar _el))))
         PATTERN

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

@@ -26,22 +26,22 @@ module RuboCop
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} _ :each_with_object (hash))
+            (call _ :each_with_object (hash))
             (args (arg $_el) (arg _memo))
-            ({send csend} (lvar _memo) :[]= (lvar _el) $!`_memo))
+            (call (lvar _memo) :[]= (lvar _el) $!`_memo))
         PATTERN
 
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            ({send csend} _ :to_h)
+            (call _ :to_h)
             (args (arg $_el))
             (array (lvar _el) $_))
         PATTERN
 
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
-          ({send csend}
+          (call
             (block
-              ({send csend} _ {:map :collect})
+              (call _ {:map :collect})
               (args (arg $_el))
               (array (lvar _el) $_))
             :to_h)
@@ -52,7 +52,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              ({send csend} _ {:map :collect})
+              (call _ {:map :collect})
               (args (arg $_el))
               (array (lvar _el) $_)))
         PATTERN

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

@@ -126,6 +126,18 @@ module RuboCop
       #     has_many :physicians, through: :appointments
       #   end
       #
+      # @example IgnoreScopes: false (default)
+      #   # bad
+      #   class Blog < ApplicationRecord
+      #     has_many :posts, -> { order(published_at: :desc) }
+      #   end
+      #
+      # @example IgnoreScopes: true
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     has_many :posts, -> { order(published_at: :desc) }
+      #   end
+      #
       # @see https://guides.rubyonrails.org/association_basics.html#bi-directional-associations
       # @see https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Setting+Inverses
       class InverseOf < Base
@@ -189,7 +201,7 @@ module RuboCop
         end
 
         def scope?(arguments)
-          arguments.any?(&:block_type?)
+          !ignore_scopes? && arguments.any?(&:block_type?)
         end
 
         def options_requiring_inverse_of?(options)
@@ -236,6 +248,10 @@ module RuboCop
             SPECIFY_MSG
           end
         end
+
+        def ignore_scopes?
+          cop_config['IgnoreScopes'] == true
+        end
       end
     end
   end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop makes sure that each migration file defines a migration class
+      # whose name matches the file name.
+      # (e.g. `20220224111111_create_users.rb` should define `CreateUsers` class.)
+      #
+      # @example
+      #   # db/migrate/20220224111111_create_users.rb
+      #
+      #   # bad
+      #   class SellBooks < ActiveRecord::Migration[7.0]
+      #   end
+      #
+      #   # good
+      #   class CreateUsers < ActiveRecord::Migration[7.0]
+      #   end
+      #
+      class MigrationClassName < Base
+        extend AutoCorrector
+
+        MSG = 'Replace with `%<corrected_class_name>s` that matches the file name.'
+
+        def on_class(node)
+          snake_class_name = to_snakecase(node.identifier.source)
+
+          return if snake_class_name == basename_without_timestamp
+
+          corrected_class_name = to_camelcase(basename_without_timestamp)
+          message = format(MSG, corrected_class_name: corrected_class_name)
+
+          add_offense(node.identifier, message: message) do |corrector|
+            corrector.replace(node.identifier, corrected_class_name)
+          end
+        end
+
+        private
+
+        def basename_without_timestamp
+          filepath = processed_source.file_path
+          basename = File.basename(filepath, '.rb')
+          basename.sub(/\A\d+_/, '')
+        end
+
+        def to_camelcase(word)
+          word.split('_').map(&:capitalize).join
+        end
+
+        def to_snakecase(word)
+          word
+            .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr('-', '_')
+            .downcase
+        end
+      end
+    end
+  end
+end

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

@@ -21,25 +21,31 @@ module RuboCop
         extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Prefer `pluck(:%<value>s)` over `%<method>s { |%<argument>s| %<element>s[:%<value>s] }`.'
+        MSG = 'Prefer `pluck(:%<value>s)` over `%<current>s`.'
 
         minimum_target_rails_version 5.0
 
         def_node_matcher :pluck_candidate?, <<~PATTERN
-          (block (send _ ${:map :collect}) (args (arg $_argument)) (send (lvar $_element) :[] (sym $_value)))
+          ({block numblock} (send _ {:map :collect}) $_argument (send (lvar $_element) :[] (sym $_value)))
         PATTERN
 
         def on_block(node)
-          pluck_candidate?(node) do |method, argument, element, value|
-            next unless argument == element
+          pluck_candidate?(node) do |argument, element, value|
+            match = if node.block_type?
+                      argument.children.first.source.to_sym == element
+                    else # numblock
+                      argument == 1 && element == :_1
+                    end
+            next unless match
 
-            message = message(method, argument, element, value)
+            message = message(value, node)
 
             add_offense(offense_range(node), message: message) do |corrector|
               corrector.replace(offense_range(node), "pluck(:#{value})")
             end
           end
         end
+        alias on_numblock on_block
 
         private
 
@@ -47,8 +53,10 @@ module RuboCop
           node.send_node.loc.selector.join(node.loc.end)
         end
 
-        def message(method, argument, element, value)
-          format(MSG, method: method, argument: argument, element: element, value: value)
+        def message(value, node)
+          current = offense_range(node).source
+
+          format(MSG, value: value, current: current)
         end
       end
     end

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

@@ -23,10 +23,21 @@ module RuboCop
       #   # good
       #   x = self[:attr]
       #   self[:attr] = val
+      #
+      # When called from within a method with the same name as the attribute,
+      # `read_attribute` and `write_attribute` must be used to prevent an
+      # infinite loop:
+      #
+      # @example
+      #
+      #   # good
+      #   def foo
+      #     bar || read_attribute(:foo)
+      #   end
       class ReadWriteAttribute < Base
         extend AutoCorrector
 
-        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+        MSG = 'Prefer `%<prefer>s`.'
         RESTRICT_ON_SEND = %i[read_attribute write_attribute].freeze
 
         def_node_matcher :read_write_attribute?, <<~PATTERN
@@ -38,27 +49,53 @@ module RuboCop
 
         def on_send(node)
           return unless read_write_attribute?(node)
+          return if within_shadowing_method?(node)
 
-          add_offense(node.loc.selector, message: message(node)) do |corrector|
-            case node.method_name
-            when :read_attribute
-              replacement = read_attribute_replacement(node)
-            when :write_attribute
-              replacement = write_attribute_replacement(node)
-            end
-
-            corrector.replace(node.source_range, replacement)
+          add_offense(node, message: build_message(node)) do |corrector|
+            corrector.replace(node.source_range, node_replacement(node))
           end
         end
 
         private
 
-        def message(node)
+        def within_shadowing_method?(node)
+          first_arg = node.first_argument
+          return false unless first_arg.respond_to?(:value)
+
+          enclosing_method = node.each_ancestor(:def).first
+          return false unless enclosing_method
+
+          shadowing_method_name = first_arg.value.to_s
+          shadowing_method_name << '=' if node.method?(:write_attribute)
+          enclosing_method.method?(shadowing_method_name)
+        end
+
+        def build_message(node)
+          if node.single_line?
+            single_line_message(node)
+          else
+            multi_line_message(node)
+          end
+        end
+
+        def single_line_message(node)
+          format(MSG, prefer: node_replacement(node))
+        end
+
+        def multi_line_message(node)
           if node.method?(:read_attribute)
-            format(MSG, prefer: 'self[:attr]', current: 'read_attribute(:attr)')
+            format(MSG, prefer: 'self[:attr]')
           else
-            format(MSG, prefer: 'self[:attr] = val',
-                        current: 'write_attribute(:attr, val)')
+            format(MSG, prefer: 'self[:attr] = val')
+          end
+        end
+
+        def node_replacement(node)
+          case node.method_name
+          when :read_attribute
+            read_attribute_replacement(node)
+          when :write_attribute
+            write_attribute_replacement(node)
           end
         end