rubocop-rails 2.9.1 → 2.11.2

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

@@ -12,20 +12,21 @@ module RuboCop
       # The cop also reports warnings when you are using `to_time` method,
       # because it doesn't know about Rails time zone either.
       #
-      # Two styles are supported for this cop. When EnforcedStyle is 'strict'
+      # Two styles are supported for this cop. When `EnforcedStyle` is 'strict'
       # then the Date methods `today`, `current`, `yesterday`, and `tomorrow`
       # are prohibited and the usage of both `to_time`
       # and 'to_time_in_current_zone' are reported as warning.
       #
-      # When EnforcedStyle is 'flexible' then only `Date.today` is prohibited
-      # and only `to_time` is reported as warning.
+      # When `EnforcedStyle` is `flexible` then only `Date.today` is prohibited.
+      #
+      # 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
       #   # bad
       #   Date.current
       #   Date.yesterday
       #   Date.today
-      #   date.to_time
       #
       #   # good
       #   Time.zone.today
@@ -34,7 +35,6 @@ module RuboCop
       # @example EnforcedStyle: flexible (default)
       #   # bad
       #   Date.today
-      #   date.to_time
       #
       #   # good
       #   Time.zone.today
@@ -43,6 +43,13 @@ module RuboCop
       #   Date.yesterday
       #   date.in_time_zone
       #
+      # @example AllowToTime: true (default)
+      #   # good
+      #   date.to_time
+      #
+      # @example AllowToTime: false
+      #   # bad
+      #   date.to_time
       class Date < Base
         include ConfigurableEnforcedStyle
 
@@ -73,7 +80,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver && bad_methods.include?(node.method_name)
-
+          return if allow_to_time? && node.method?(:to_time)
           return if safe_chain?(node) || safe_to_time?(node)
 
           check_deprecated_methods(node)
@@ -139,6 +146,10 @@ module RuboCop
           end
         end
 
+        def allow_to_time?
+          cop_config.fetch('AllowToTime', true)
+        end
+
         def good_days
           style == :strict ? [] : %i[current yesterday tomorrow]
         end

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

@@ -32,18 +32,20 @@ module RuboCop
       #   # good
       #   Gem::Specification.find_by_name('backend').gem_dir
       class DynamicFindBy < Base
+        include ActiveRecordHelper
         extend AutoCorrector
 
         MSG = 'Use `%<static_name>s` instead of dynamic `%<method>s`.'
         METHOD_PATTERN = /^find_by_(.+?)(!)?$/.freeze
+        IGNORED_ARGUMENT_TYPES = %i[hash splat].freeze
 
         def on_send(node)
-          return if allowed_invocation?(node)
+          return if node.receiver.nil? && !inherit_active_record_base?(node) || allowed_invocation?(node)
 
           method_name = node.method_name
           static_name = static_method_name(method_name)
           return unless static_name
-          return if node.arguments.any?(&:splat_type?)
+          return if node.arguments.any? { |argument| IGNORED_ARGUMENT_TYPES.include?(argument.type) }
 
           message = format(MSG, static_name: static_name, method: method_name)
           add_offense(node, message: message) do |corrector|

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that blocks are used for interpolated strings passed to
+      # `Rails.logger.debug`.
+      #
+      # By default, Rails production environments use the `:info` log level.
+      # At the `:info` log level, `Rails.logger.debug` statements do not result
+      # in log output. However, Ruby must eagerly evaluate interpolated string
+      # arguments passed as method arguments. Passing a block to
+      # `Rails.logger.debug` prevents costly evaluation of interpolated strings
+      # when no output would be produced anyway.
+      #
+      # @example
+      #   #bad
+      #   Rails.logger.debug "The time is #{Time.zone.now}."
+      #
+      #   #good
+      #   Rails.logger.debug { "The time is #{Time.zone.now}." }
+      #
+      class EagerEvaluationLogMessage < Base
+        extend AutoCorrector
+
+        MSG = 'Pass a block to `Rails.logger.debug`.'
+        RESTRICT_ON_SEND = %i[debug].freeze
+
+        def_node_matcher :interpolated_string_passed_to_debug, <<~PATTERN
+          (send
+            (send
+              (const {cbase nil?} :Rails)
+              :logger
+            )
+            :debug
+            $(dstr ...)
+          )
+        PATTERN
+
+        def on_send(node)
+          return if node.parent&.block_type?
+
+          interpolated_string_passed_to_debug(node) do |arguments|
+            message = format(MSG)
+
+            range = replacement_range(node)
+            replacement = replacement_source(node, arguments)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, replacement)
+            end
+          end
+        end
+
+        private
+
+        def replacement_range(node)
+          stop = node.loc.expression.end
+          start = node.loc.selector.end
+
+          if node.parenthesized_call?
+            stop.with(begin_pos: start.begin_pos)
+          else
+            stop.with(begin_pos: start.begin_pos + 1)
+          end
+        end
+
+        def replacement_source(node, arguments)
+          if node.parenthesized_call?
+            " { #{arguments.source} }"
+          else
+            "{ #{arguments.source} }"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -20,8 +20,7 @@ module RuboCop
 
         MSG = 'Favor `%<bang>sRails.env.%<env>s?` over `%<source>s`.'
 
-        SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always ' \
-          'evaluate to `false`.'
+        SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always evaluate to `false`.'
 
         RESTRICT_ON_SEND = %i[== !=].freeze
 

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for direct access to environment variables through the
+      # `ENV` variable within the application code. This can lead to runtime
+      # errors due to misconfiguration that could have been discovered at boot
+      # time if the environment variables were loaded as part of initialization
+      # and copied into the application's configuration or secrets. The cop can
+      # be configured to allow either reads or writes if required.
+      #
+      # @example
+      #   # good
+      #   Rails.application.config.foo
+      #   Rails.application.config.x.foo.bar
+      #   Rails.application.secrets.foo
+      #   Rails.application.config.foo = "bar"
+      #
+      # @example AllowReads: false (default)
+      #   # bad
+      #   ENV["FOO"]
+      #   ENV.fetch("FOO")
+      #
+      # @example AllowReads: true
+      #   # good
+      #   ENV["FOO"]
+      #   ENV.fetch("FOO")
+      #
+      # @example AllowWrites: false (default)
+      #   # bad
+      #   ENV["FOO"] = "bar"
+      #
+      # @example AllowWrites: true
+      #   # good
+      #   ENV["FOO"] = "bar"
+      class EnvironmentVariableAccess < Base
+        READ_MSG = 'Do not read from `ENV` directly post initialization.'
+        WRITE_MSG = 'Do not write to `ENV` directly post initialization.'
+
+        def on_const(node)
+          add_offense(node, message: READ_MSG) if env_read?(node) && !allow_reads?
+          add_offense(node, message: WRITE_MSG) if env_write?(node) && !allow_writes?
+        end
+
+        def_node_search :env_read?, <<~PATTERN
+          ^(send (const {cbase nil?} :ENV) !:[]= ...)
+        PATTERN
+
+        def_node_search :env_write?, <<~PATTERN
+          {^(indexasgn (const {cbase nil?} :ENV) ...)
+           ^(send (const {cbase nil?} :ENV) :[]= ...)}
+        PATTERN
+
+        private
+
+        def allow_reads?
+          cop_config['AllowReads'] == true
+        end
+
+        def allow_writes?
+          cop_config['AllowWrites'] == true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for expanded date range. It only compatible `..` range is targeted.
+      # Incompatible `...` range is ignored.
+      #
+      # @example
+      #   # bad
+      #   date.beginning_of_day..date.end_of_day
+      #   date.beginning_of_week..date.end_of_week
+      #   date.beginning_of_month..date.end_of_month
+      #   date.beginning_of_quarter..date.end_of_quarter
+      #   date.beginning_of_year..date.end_of_year
+      #
+      #   # good
+      #   date.all_day
+      #   date.all_week
+      #   date.all_month
+      #   date.all_quarter
+      #   date.all_year
+      #
+      class ExpandedDateRange < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `%<preferred_method>s` instead.'
+
+        minimum_target_rails_version 5.1
+
+        def_node_matcher :expanded_date_range, <<~PATTERN
+          (irange
+            (send
+              $_ {:beginning_of_day :beginning_of_week :beginning_of_month :beginning_of_quarter :beginning_of_year})
+            (send
+              $_ {:end_of_day :end_of_week :end_of_month :end_of_quarter :end_of_year}))
+        PATTERN
+
+        PREFERRED_METHODS = {
+          beginning_of_day: 'all_day',
+          beginning_of_week: 'all_week',
+          beginning_of_month: 'all_month',
+          beginning_of_quarter: 'all_quarter',
+          beginning_of_year: 'all_year'
+        }.freeze
+
+        MAPPED_DATE_RANGE_METHODS = {
+          beginning_of_day: :end_of_day,
+          beginning_of_week: :end_of_week,
+          beginning_of_month: :end_of_month,
+          beginning_of_quarter: :end_of_quarter,
+          beginning_of_year: :end_of_year
+        }.freeze
+
+        def on_irange(node)
+          return unless expanded_date_range(node)
+
+          begin_node = node.begin
+          end_node = node.end
+          return unless same_receiver?(begin_node, end_node)
+
+          beginning_method = begin_node.method_name
+          end_method = end_node.method_name
+          return unless use_mapped_methods?(beginning_method, end_method)
+
+          preferred_method = "#{begin_node.receiver.source}.#{PREFERRED_METHODS[beginning_method]}"
+
+          add_offense(node, message: format(MSG, preferred_method: preferred_method)) do |corrector|
+            corrector.replace(node, preferred_method)
+          end
+        end
+
+        private
+
+        def same_receiver?(begin_node, end_node)
+          begin_node.receiver.source == end_node.receiver.source
+        end
+
+        def use_mapped_methods?(beginning_method, end_method)
+          MAPPED_DATE_RANGE_METHODS[beginning_method] == end_method
+        end
+      end
+    end
+  end
+end

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

@@ -29,10 +29,8 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG_SLASHES = 'Please use `Rails.root.join(\'path/to\')` ' \
-                      'instead.'
-        MSG_ARGUMENTS = 'Please use `Rails.root.join(\'path\', \'to\')` ' \
-                        'instead.'
+        MSG_SLASHES = 'Prefer `Rails.root.join(\'path/to\')`.'
+        MSG_ARGUMENTS = 'Prefer `Rails.root.join(\'path\', \'to\')`.'
         RESTRICT_ON_SEND = %i[join].freeze
 
         def_node_matcher :file_join_nodes?, <<~PATTERN

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

@@ -3,16 +3,27 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop is used to identify usages of `where.first` and
-      # change them to use `find_by` instead.
+      # This cop is used to identify usages of `where.take` and change them to use `find_by` instead.
+      #
+      # And `where(...).first` can return different results from `find_by`.
+      # (They order records differently, so the "first" record can be different.)
+      #
+      # If you also want to detect `where.first`, you can set `IgnoreWhereFirst` to false.
       #
       # @example
       #   # bad
-      #   User.where(name: 'Bruce').first
       #   User.where(name: 'Bruce').take
       #
       #   # good
       #   User.find_by(name: 'Bruce')
+      #
+      # @example IgnoreWhereFirst: true (default)
+      #   # good
+      #   User.where(name: 'Bruce').first
+      #
+      # @example IgnoreWhereFirst: false
+      #   # bad
+      #   User.where(name: 'Bruce').first
       class FindBy < Base
         include RangeHelp
         extend AutoCorrector
@@ -20,14 +31,11 @@ module RuboCop
         MSG = 'Use `find_by` instead of `where.%<method>s`.'
         RESTRICT_ON_SEND = %i[first take].freeze
 
-        def_node_matcher :where_first?, <<~PATTERN
-          (send ({send csend} _ :where ...) {:first :take})
-        PATTERN
-
         def on_send(node)
-          return unless where_first?(node)
+          return unless node.arguments.empty? && where_method?(node.receiver)
+          return if ignore_where_first? && node.method?(:first)
 
-          range = range_between(node.receiver.loc.selector.begin_pos, node.loc.selector.end_pos)
+          range = offense_range(node)
 
           add_offense(range, message: format(MSG, method: node.method_name)) do |corrector|
             autocorrect(corrector, node)
@@ -37,10 +45,17 @@ module RuboCop
 
         private
 
+        def where_method?(receiver)
+          return false unless receiver
+
+          receiver.respond_to?(:method?) && receiver.method?(:where)
+        end
+
+        def offense_range(node)
+          range_between(node.receiver.loc.selector.begin_pos, node.loc.selector.end_pos)
+        end
+
         def autocorrect(corrector, node)
-          # Don't autocorrect where(...).first, because it can return different
-          # results from find_by. (They order records differently, so the
-          # 'first' record can be different.)
           return if node.method?(:first)
 
           where_loc = node.receiver.loc.selector
@@ -49,6 +64,10 @@ module RuboCop
           corrector.replace(where_loc, 'find_by')
           corrector.replace(first_loc, '')
         end
+
+        def ignore_where_first?
+          cop_config.fetch('IgnoreWhereFirst', true)
+        end
       end
     end
   end

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

@@ -17,6 +17,7 @@ module RuboCop
       #   # good
       #   User.order(:foo).each
       class FindEach < Base
+        include ActiveRecordHelper
         extend AutoCorrector
 
         MSG = 'Use `find_each` instead of `each`.'
@@ -30,6 +31,7 @@ module RuboCop
         def on_send(node)
           return unless node.receiver&.send_type?
           return unless SCOPE_METHODS.include?(node.receiver.method_name)
+          return if node.receiver.receiver.nil? && !inherit_active_record_base?(node)
           return if ignored?(node)
 
           range = node.loc.selector

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

@@ -5,7 +5,9 @@ module RuboCop
     module Rails
       # This cop looks for `has_many` or `has_one` associations that don't
       # specify a `:dependent` option.
-      # It doesn't register an offense if `:through` option was specified.
+      #
+      # It doesn't register an offense if `:through` or `dependent: nil`
+      # is specified, or if the model is read-only.
       #
       # @example
       #   # bad
@@ -18,8 +20,18 @@ module RuboCop
       #   class User < ActiveRecord::Base
       #     has_many :comments, dependent: :restrict_with_exception
       #     has_one :avatar, dependent: :destroy
+      #     has_many :articles, dependent: nil
       #     has_many :patients, through: :appointments
       #   end
+      #
+      #   class User < ActiveRecord::Base
+      #     has_many :comments
+      #     has_one :avatar
+      #
+      #     def readonly?
+      #       true
+      #     end
+      #   end
       class HasManyOrHasOneDependent < Base
         MSG = 'Specify a `:dependent` option.'
         RESTRICT_ON_SEND = %i[has_many has_one].freeze
@@ -37,7 +49,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :dependent_option?, <<~PATTERN
-          (pair (sym :dependent) !nil)
+          (pair (sym :dependent) {!nil (nil)})
         PATTERN
 
         def_node_matcher :present_option?, <<~PATTERN
@@ -51,8 +63,20 @@ module RuboCop
             (args) ...)
         PATTERN
 
+        def_node_matcher :association_extension_block?, <<~PATTERN
+          (block
+            (send nil? :has_many _)
+            (args) ...)
+        PATTERN
+
+        def_node_matcher :readonly?, <<~PATTERN
+          (def :readonly?
+            (args)
+            (true))
+        PATTERN
+
         def on_send(node)
-          return if active_resource?(node.parent)
+          return if active_resource?(node.parent) || readonly_model?(node)
           return if !association_without_options?(node) && valid_options?(association_with_options?(node))
           return if valid_options_in_with_options_block?(node)
 
@@ -61,10 +85,16 @@ module RuboCop
 
         private
 
+        def readonly_model?(node)
+          return false unless (parent = node.parent)
+
+          parent.each_descendant(:def).any? { |def_node| readonly?(def_node) }
+        end
+
         def valid_options_in_with_options_block?(node)
           return true unless node.parent
 
-          n = node.parent.begin_type? ? node.parent.parent : node.parent
+          n = node.parent.begin_type? || association_extension_block?(node.parent) ? node.parent.parent : node.parent
 
           contain_valid_options_in_with_options_block?(n)
         end