rubocop-rails 2.11.2 → 2.19.1

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

@@ -3,8 +3,12 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop is used to identify usages of `all.each` and
-      # change them to use `all.find_each` instead.
+      # Identifies usages of `all.each` and change them to use `all.find_each` instead.
+      #
+      # @safety
+      #   This cop is unsafe if the receiver object is not an Active Record object.
+      #   Also, `all.each` returns an `Array` instance and `all.find_each` returns nil,
+      #   so the return values are different.
       #
       # @example
       #   # bad
@@ -13,11 +17,17 @@ module RuboCop
       #   # good
       #   User.all.find_each
       #
-      # @example IgnoredMethods: ['order']
+      # @example AllowedMethods: ['order']
+      #   # good
+      #   User.order(:foo).each
+      #
+      # @example AllowedPattern: ['order']
       #   # good
       #   User.order(:foo).each
       class FindEach < Base
         include ActiveRecordHelper
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Use `find_each` instead of `each`.'
@@ -43,8 +53,21 @@ module RuboCop
         private
 
         def ignored?(node)
+          return true if active_model_error_where?(node.receiver)
+
           method_chain = node.each_node(:send).map(&:method_name)
-          (cop_config['IgnoredMethods'].map(&:to_sym) & method_chain).any?
+
+          method_chain.any? { |method_name| allowed_method?(method_name) || matches_allowed_pattern?(method_name) }
+        end
+
+        def active_model_error_where?(node)
+          node.method?(:where) && active_model_error?(node.receiver)
+        end
+
+        def active_model_error?(node)
+          return false if node.nil?
+
+          node.send_type? && node.method?(:errors)
         end
       end
     end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies usages of `travel_to` with an argument of the current time and
+      # change them to use `freeze_time` instead.
+      #
+      # @safety
+      #   This cop’s autocorrection is unsafe because `freeze_time` just delegates to
+      #   `travel_to` with a default `Time.now`, it is not strictly equivalent to `Time.now`
+      #   if the argument of `travel_to` is the current time considering time zone.
+      #
+      # @example
+      #   # bad
+      #   travel_to(Time.now)
+      #   travel_to(Time.new)
+      #   travel_to(DateTime.now)
+      #   travel_to(Time.current)
+      #   travel_to(Time.zone.now)
+      #   travel_to(Time.now.in_time_zone)
+      #   travel_to(Time.current.to_time)
+      #
+      #   # good
+      #   freeze_time
+      #
+      class FreezeTime < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.2
+
+        MSG = 'Use `freeze_time` instead of `travel_to`.'
+        NOW_METHODS = %i[now new current].freeze
+        CONVERT_METHODS = %i[to_time in_time_zone].freeze
+        RESTRICT_ON_SEND = %i[travel_to].freeze
+
+        # @!method time_now?(node)
+        def_node_matcher :time_now?, <<~PATTERN
+          (const {nil? cbase} {:Time :DateTime})
+        PATTERN
+
+        # @!method zoned_time_now?(node)
+        def_node_matcher :zoned_time_now?, <<~PATTERN
+          (send (const {nil? cbase} :Time) :zone)
+        PATTERN
+
+        def on_send(node)
+          child_node, method_name, time_argument = *node.first_argument&.children
+          return if time_argument || !child_node
+          return unless current_time?(child_node, method_name) || current_time_with_convert?(child_node, method_name)
+
+          add_offense(node) do |corrector|
+            last_argument = node.last_argument
+            freeze_time_method = last_argument.block_pass_type? ? "freeze_time(#{last_argument.source})" : 'freeze_time'
+            corrector.replace(node, freeze_time_method)
+          end
+        end
+
+        private
+
+        def current_time?(node, method_name)
+          return false unless NOW_METHODS.include?(method_name)
+
+          node.send_type? ? zoned_time_now?(node) : time_now?(node)
+        end
+
+        def current_time_with_convert?(node, method_name)
+          return false unless CONVERT_METHODS.include?(method_name)
+
+          child_node, child_method_name, time_argument = *node.children
+          return if time_argument
+
+          current_time?(child_node, child_method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of the has_and_belongs_to_many macro.
+      # Checks for the use of the has_and_belongs_to_many macro.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for `has_many` or `has_one` associations that don't
+      # Looks for `has_many` or `has_one` associations that don't
       # specify a `:dependent` option.
       #
       # It doesn't register an offense if `:through` or `dependent: nil`
@@ -37,15 +37,15 @@ module RuboCop
         RESTRICT_ON_SEND = %i[has_many has_one].freeze
 
         def_node_search :active_resource_class?, <<~PATTERN
-          (const (const nil? :ActiveResource) :Base)
+          (const (const {nil? cbase} :ActiveResource) :Base)
         PATTERN
 
         def_node_matcher :association_without_options?, <<~PATTERN
-          (send nil? {:has_many :has_one} _)
+          (send _ {:has_many :has_one} _)
         PATTERN
 
         def_node_matcher :association_with_options?, <<~PATTERN
-          (send nil? {:has_many :has_one} _ (hash $...))
+          (send _ {:has_many :has_one} ... (hash $...))
         PATTERN
 
         def_node_matcher :dependent_option?, <<~PATTERN
@@ -100,20 +100,22 @@ module RuboCop
         end
 
         def contain_valid_options_in_with_options_block?(node)
-          if with_options_block(node)
-            return true if valid_options?(with_options_block(node))
+          if (options = with_options_block(node))
+            return true if valid_options?(options)
 
             return false unless node.parent
 
-            return true if contain_valid_options_in_with_options_block?(
-              node.parent.parent
-            )
+            return true if contain_valid_options_in_with_options_block?(node.parent.parent)
           end
 
           false
         end
 
         def valid_options?(options)
+          return false if options.nil?
+
+          options = extract_option_if_kwsplat(options)
+
           return true unless options
           return true if options.any? do |o|
             dependent_option?(o) || present_option?(o)
@@ -122,6 +124,14 @@ module RuboCop
           false
         end
 
+        def extract_option_if_kwsplat(options)
+          if options.first.kwsplat_type? && options.first.children.first.hash_type?
+            return options.first.children.first.pairs
+          end
+
+          options
+        end
+
         def active_resource?(node)
           return false if node.nil?
 

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

@@ -3,14 +3,14 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for use of the helper methods which reference
+      # Checks for use of the helper methods which reference
       # instance variables.
       #
       # Relying on instance variables makes it difficult to re-use helper
       # methods.
       #
       # If it seems awkward to explicitly pass in each dependent
-      # variable, consider moving the behaviour elsewhere, for
+      # variable, consider moving the behavior elsewhere, for
       # example to a model, decorator or presenter.
       #
       # Provided that a class inherits `ActionView::Helpers::FormBuilder`,
@@ -37,7 +37,7 @@ module RuboCop
         def_node_matcher :form_builder_class?, <<~PATTERN
           (const
             (const
-               (const nil? :ActionView) :Helpers) :FormBuilder)
+               (const {nil? cbase} :ActionView) :Helpers) :FormBuilder)
         PATTERN
 
         def on_ivar(node)

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

@@ -3,13 +3,16 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop is used to identify usages of http methods like `get`, `post`,
+      # Identifies usages of http methods like `get`, `post`,
       # `put`, `patch` without the usage of keyword arguments in your tests and
       # change them to use keyword args. This cop only applies to Rails >= 5.
       # If you are running Rails < 5 you should disable the
       # Rails/HttpPositionalArguments cop or set your TargetRailsVersion in your
       # .rubocop.yml file to 4.2.
       #
+      # NOTE: It does not detect any cases where `include Rack::Test::Methods` is used
+      # which makes the http methods incompatible behavior.
+      #
       # @example
       #   # bad
       #   get :new, { user_id: 1}
@@ -22,11 +25,9 @@ module RuboCop
         extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Use keyword arguments instead of ' \
-              'positional arguments for http call: `%<verb>s`.'
-        KEYWORD_ARGS = %i[
-          method params session body flash xhr as headers env to
-        ].freeze
+        MSG = 'Use keyword arguments instead of positional arguments for http call: `%<verb>s`.'
+        KEYWORD_ARGS = %i[method params session body flash xhr as headers env to].freeze
+        ROUTING_METHODS = %i[draw routes].freeze
         RESTRICT_ON_SEND = %i[get post put patch delete head].freeze
 
         minimum_target_rails_version 5.0
@@ -39,7 +40,16 @@ module RuboCop
           (hash (kwsplat _))
         PATTERN
 
+        def_node_matcher :include_rack_test_methods?, <<~PATTERN
+          (send nil? :include
+            (const
+              (const
+                (const {nil? cbase} :Rack) :Test) :Methods))
+        PATTERN
+
         def on_send(node)
+          return if in_routing_block?(node) || use_rack_test_methods?
+
           http_request?(node) do |data|
             return unless needs_conversion?(data)
 
@@ -56,20 +66,29 @@ module RuboCop
               # that represents the path/action on the Rails controller
               # the data is the http parameters and environment sent in
               # the Rails 5 http call
-              corrector.replace(node.loc.expression, correction(node))
+              corrector.replace(node, correction(node))
             end
           end
         end
 
         private
 
+        def in_routing_block?(node)
+          !!node.each_ancestor(:block).detect { |block| ROUTING_METHODS.include?(block.method_name) }
+        end
+
+        def use_rack_test_methods?
+          processed_source.ast.each_descendant(:send).any? do |node|
+            include_rack_test_methods?(node)
+          end
+        end
+
         def needs_conversion?(data)
           return true unless data.hash_type?
           return false if kwsplat_hash?(data)
 
           data.each_pair.none? do |pair|
-            special_keyword_arg?(pair.key) ||
-              format_arg?(pair.key) && data.pairs.one?
+            special_keyword_arg?(pair.key) || (format_arg?(pair.key) && data.pairs.one?)
           end
         end
 
@@ -91,8 +110,7 @@ module RuboCop
           return '' if data.hash_type? && data.empty?
 
           hash_data = if data.hash_type?
-                        format('{ %<data>s }',
-                               data: data.pairs.map(&:source).join(', '))
+                        format('{ %<data>s }', data: data.pairs.map(&:source).join(', '))
                       else
                         # user supplies an object,
                         # no need to surround with braces

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

@@ -66,7 +66,7 @@ module RuboCop
             return unless checker.offensive?
 
             add_offense(checker.node, message: checker.message) do |corrector|
-              corrector.replace(checker.node.loc.expression, checker.preferred_style)
+              corrector.replace(checker.node, checker.preferred_style)
             end
           end
         end
@@ -84,10 +84,8 @@ module RuboCop
 
         # :nodoc:
         class SymbolicStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` ' \
-                        'to define HTTP status code.'
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` to define HTTP status code.'
 
           attr_reader :node
 
@@ -118,17 +116,14 @@ module RuboCop
           end
 
           def custom_http_status_code?
-            node.int_type? &&
-              !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
+            node.int_type? && !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
           end
         end
 
         # :nodoc:
         class NumericStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` ' \
-                        'to define HTTP status code.'
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` to define HTTP status code.'
           PERMITTED_STATUS = %i[error success missing redirect].freeze
 
           attr_reader :node

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # 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.'
+
+        RESTRICT_ON_SEND = %i[translate t].freeze
+
+        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_assignment.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of `I18n.locale=` method.
+      # Checks for the use of `I18n.locale=` method.
       #
       # The `locale` attribute persists for the rest of the Ruby runtime, potentially causing
       # unexpected behavior at a later time.

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 redirect_back []= 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, :redirect_back
+            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/ignored_columns_assignment.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for assignments of `ignored_columns` that may override previous
+      # assignments.
+      #
+      # Overwriting previous assignments is usually a mistake, since it will
+      # un-ignore the first set of columns. Since duplicate column names is not
+      # a problem, it is better to simply append to the list.
+      #
+      # @example
+      #
+      #   # bad
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns = [:one]
+      #   end
+      #
+      #   # bad
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns = [:one, :two]
+      #   end
+      #
+      #   # good
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns += [:one, :two]
+      #   end
+      #
+      #   # good
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns += [:one]
+      #     self.ignored_columns += [:two]
+      #   end
+      #
+      class IgnoredColumnsAssignment < Base
+        extend AutoCorrector
+
+        MSG = 'Use `+=` instead of `=`.'
+        RESTRICT_ON_SEND = %i[ignored_columns=].freeze
+
+        def on_send(node)
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '+=')
+          end
+        end
+      end
+    end
+  end
+end