rubocop-rails 2.17.4 → 2.19.0

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

@@ -78,7 +78,7 @@ module RuboCop
         def on_send(node)
           duration_arithmetic_argument?(node) do |*operation|
             add_offense(node) do |corrector|
-              corrector.replace(node.source_range, corrected_source(*operation))
+              corrector.replace(node, corrected_source(*operation))
             end
           end
         end

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

@@ -99,7 +99,7 @@ module RuboCop
 
         def autocorrect_argument_keywords(corrector, node, keywords)
           keywords.each.with_index do |keyword, idx|
-            corrector.insert_before(node.arguments[idx].loc.expression, keyword)
+            corrector.insert_before(node.arguments[idx], keyword)
           end
         end
 

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

@@ -59,7 +59,7 @@ module RuboCop
         private
 
         def replacement_range(node)
-          stop = node.loc.expression.end
+          stop = node.source_range.end
           start = node.loc.selector.end
 
           if node.parenthesized_call?

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

@@ -42,7 +42,7 @@ module RuboCop
                   "#{source(elem)} => #{index}"
                 end.join(', ')
 
-                corrector.replace(array.loc.expression, "{#{hash}}")
+                corrector.replace(array, "{#{hash}}")
               end
             end
           end

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

@@ -84,7 +84,7 @@ module RuboCop
         def autocorrect(corrector, node)
           replacement = build_predicate_method(node)
 
-          corrector.replace(node.source_range, replacement)
+          corrector.replace(node, replacement)
         end
 
         def build_predicate_method(node)

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

@@ -3,34 +3,43 @@
 module RuboCop
   module Cop
     module Rails
-      # Identifies usages of file path joining process
-      # to use `Rails.root.join` clause. It is used to add uniformity when
-      # joining paths.
+      # Identifies usages of file path joining process to use `Rails.root.join` clause.
+      # It is used to add uniformity when joining paths.
       #
       # @example EnforcedStyle: slashes (default)
       #   # bad
       #   Rails.root.join('app', 'models', 'goober')
+      #
+      #   # good
+      #   Rails.root.join('app/models/goober')
+      #
+      #   # bad
       #   File.join(Rails.root, 'app/models/goober')
       #   "#{Rails.root}/app/models/goober"
       #
       #   # good
-      #   Rails.root.join('app/models/goober')
+      #   Rails.root.join('app/models/goober').to_s
       #
       # @example EnforcedStyle: arguments
       #   # bad
       #   Rails.root.join('app/models/goober')
+      #
+      #   # good
+      #   Rails.root.join('app', 'models', 'goober')
+      #
+      #   # bad
       #   File.join(Rails.root, 'app/models/goober')
       #   "#{Rails.root}/app/models/goober"
       #
       #   # good
-      #   Rails.root.join('app', 'models', 'goober')
+      #   Rails.root.join('app', 'models', 'goober').to_s
       #
       class FilePath < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG_SLASHES = 'Prefer `Rails.root.join(\'path/to\')`.'
-        MSG_ARGUMENTS = 'Prefer `Rails.root.join(\'path\', \'to\')`.'
+        MSG_SLASHES = 'Prefer `Rails.root.join(\'path/to\')%<to_s>s`.'
+        MSG_ARGUMENTS = 'Prefer `Rails.root.join(\'path\', \'to\')%<to_s>s`.'
         RESTRICT_ON_SEND = %i[join].freeze
 
         def_node_matcher :file_join_nodes?, <<~PATTERN
@@ -53,7 +62,7 @@ module RuboCop
           return unless last_child_source.start_with?('.') || last_child_source.include?(File::SEPARATOR)
           return if last_child_source.start_with?(':')
 
-          register_offense(node)
+          register_offense(node, require_to_s: true)
         end
 
         def on_send(node)
@@ -68,7 +77,7 @@ module RuboCop
           return unless file_join_nodes?(node)
           return unless node.arguments.any? { |e| rails_root_nodes?(e) }
 
-          register_offense(node)
+          register_offense(node, require_to_s: true)
         end
 
         def check_for_rails_root_join_with_string_arguments(node)
@@ -78,7 +87,7 @@ module RuboCop
           return unless node.arguments.size > 1
           return unless node.arguments.all?(&:str_type?)
 
-          register_offense(node)
+          register_offense(node, require_to_s: false)
         end
 
         def check_for_rails_root_join_with_slash_separated_path(node)
@@ -87,21 +96,28 @@ module RuboCop
           return unless rails_root_join_nodes?(node)
           return unless node.arguments.any? { |arg| string_with_slash?(arg) }
 
-          register_offense(node)
+          register_offense(node, require_to_s: false)
         end
 
         def string_with_slash?(node)
           node.str_type? && node.source.include?('/')
         end
 
-        def register_offense(node)
+        def register_offense(node, require_to_s:)
           line_range = node.loc.column...node.loc.last_column
           source_range = source_range(processed_source.buffer, node.first_line, line_range)
-          add_offense(source_range)
+          require_to_s = false if node.dstr_type?
+
+          message = build_message(require_to_s)
+
+          add_offense(source_range, message: message)
         end
 
-        def message(_range)
-          format(style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES)
+        def build_message(require_to_s)
+          message_template = style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES
+          to_s = require_to_s ? '.to_s' : ''
+
+          format(message_template, to_s: to_s)
         end
       end
     end

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

@@ -65,11 +65,11 @@ module RuboCop
         end
 
         def where_take_offense_range(node, where)
-          range_between(where.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(where.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def find_by_offense_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
 
         def build_good_method(id_value)

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

@@ -3,8 +3,12 @@
 module RuboCop
   module Cop
     module Rails
-      # Identifies 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

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

@@ -26,6 +26,9 @@ module RuboCop
       #
       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

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

@@ -41,11 +41,11 @@ module RuboCop
         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

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

@@ -10,6 +10,9 @@ module RuboCop
       # 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}
@@ -37,8 +40,15 @@ 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)
+          return if in_routing_block?(node) || use_rack_test_methods?
 
           http_request?(node) do |data|
             return unless needs_conversion?(data)
@@ -56,7 +66,7 @@ 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
@@ -67,6 +77,12 @@ module RuboCop
           !!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/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

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

@@ -35,8 +35,6 @@ module RuboCop
       #     skip_before_action :login_required,
       #       if: -> { trusted_origin? && action_name != "admin" }
       #   end
-      #
-      # @see https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-_normalize_callback_options
       class IgnoredSkipActionFilterOption < Base
         MSG = <<~MSG.chomp.freeze
           `%<ignore>s` option will be ignored when `%<prefer>s` and `%<ignore>s` are used together.

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

@@ -137,9 +137,6 @@ module RuboCop
       #   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
         SPECIFY_MSG = 'Specify an `:inverse_of` option.'
         NIL_MSG = 'You specified `inverse_of: nil`, you probably meant to use `inverse_of: false`.'

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

@@ -144,19 +144,29 @@ module RuboCop
         end
 
         def aliased_action_methods(node, defined_methods)
-          alias_methods = node.each_child_node(:send).select { |send_node| send_node.method?(:alias_method) }
-
-          hash_of_alias_methods = alias_methods.each_with_object({}) do |alias_method, result|
-            result[alias_method.last_argument.value] = alias_method.first_argument.value
-          end
-
+          alias_methods = alias_methods(node)
           defined_methods.each_with_object([]) do |defined_method, aliased_method|
-            if (new_method_name = hash_of_alias_methods[defined_method])
+            if (new_method_name = alias_methods[defined_method])
               aliased_method << new_method_name
             end
           end
         end
 
+        def alias_methods(node)
+          result = {}
+          node.each_child_node(:send, :alias) do |child_node|
+            case child_node.type
+            when :send
+              if child_node.method?(:alias_method)
+                result[child_node.last_argument.value] = child_node.first_argument.value
+              end
+            when :alias
+              result[child_node.old_identifier.value] = child_node.new_identifier.value
+            end
+          end
+          result
+        end
+
         # @param node [RuboCop::AST::Node]
         # @return [Array<Symbol>]
         def array_values(node) # rubocop:disable Metrics/MethodLength

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

@@ -68,7 +68,7 @@ module RuboCop
 
         def append_to_rel(rel_node, corrector)
           existing_rel = rel_node.children.last.value
-          str_range = rel_node.children.last.loc.expression.adjust(begin_pos: 1, end_pos: -1)
+          str_range = rel_node.children.last.source_range.adjust(begin_pos: 1, end_pos: -1)
           corrector.replace(str_range, "#{existing_rel} noopener")
         end
 

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

@@ -77,7 +77,7 @@ module RuboCop
             corrector.replace(node.loc.name, "#{name}Mailer")
           else
             name = node.children.last
-            corrector.replace(node.source_range, "#{name}Mailer")
+            corrector.replace(node, "#{name}Mailer")
           end
         end
 

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

@@ -26,7 +26,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[!].freeze
 
         def_node_matcher :negate_include_call?, <<~PATTERN
-          (send (send $_ :include? $_) :!)
+          (send (send $!nil? :include? $_) :!)
         PATTERN
 
         def on_send(node)

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

@@ -21,7 +21,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[add_column add_reference].freeze
 
         def_node_matcher :add_not_null_column?, <<~PATTERN
-          (send nil? :add_column _ _ _ (hash $...))
+          (send nil? :add_column _ _ $_ (hash $...))
         PATTERN
 
         def_node_matcher :add_not_null_reference?, <<~PATTERN
@@ -44,17 +44,20 @@ module RuboCop
         private
 
         def check_add_column(node)
-          pairs = add_not_null_column?(node)
-          check_pairs(pairs)
+          add_not_null_column?(node) do |type, pairs|
+            return if type.value == :virtual || type.value == 'virtual'
+
+            check_pairs(pairs)
+          end
         end
 
         def check_add_reference(node)
-          pairs = add_not_null_reference?(node)
-          check_pairs(pairs)
+          add_not_null_reference?(node) do |pairs|
+            check_pairs(pairs)
+          end
         end
 
         def check_pairs(pairs)
-          return unless pairs
           return if pairs.any? { |pair| default_option?(pair) }
 
           null_false = pairs.find { |pair| null_false?(pair) }

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

@@ -39,7 +39,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless (output?(node) || io_output?(node)) && node.arguments?
+          return if node.parent&.call_type?
+          return unless output?(node) || io_output?(node)
 
           range = offense_range(node)
 
@@ -56,7 +57,7 @@ module RuboCop
 
         def offense_range(node)
           if node.receiver
-            range_between(node.loc.expression.begin_pos, node.loc.selector.end_pos)
+            range_between(node.source_range.begin_pos, node.loc.selector.end_pos)
           else
             node.loc.selector
           end

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

@@ -66,8 +66,12 @@ module RuboCop
         MSG = 'Tagging a string as html safe may be a security risk.'
         RESTRICT_ON_SEND = %i[html_safe raw safe_concat].freeze
 
+        def_node_search :i18n_method?, <<~PATTERN
+          (send {nil? (const {nil? cbase} :I18n)} {:t :translate :l :localize} ...)
+        PATTERN
+
         def on_send(node)
-          return if non_interpolated_string?(node)
+          return if non_interpolated_string?(node) || i18n_method?(node)
 
           return unless looks_like_rails_html_safe?(node) ||
                         looks_like_rails_raw?(node) ||

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

@@ -9,6 +9,18 @@ module RuboCop
       # element in an enumerable. When called on an Active Record relation, it
       # results in a more efficient query that only selects the necessary key.
       #
+      # @safety
+      #   This cop is unsafe because model can use column aliases.
+      #
+      #   [source,ruby]
+      #   ----
+      #   # Original code
+      #   User.select('name AS nickname').map { |user| user[:nickname] } # => array of nicknames
+      #
+      #   # After autocorrection
+      #   User.select('name AS nickname').pluck(:nickname) # => raises ActiveRecord::StatementInvalid
+      #   ----
+      #
       # @example
       #   # bad
       #   Post.published.map { |post| post[:title] }
@@ -31,7 +43,7 @@ module RuboCop
 
         def on_block(node)
           pluck_candidate?(node) do |argument, key|
-            next unless use_one_block_argument?(argument)
+            next if key.regexp_type? || !use_one_block_argument?(argument)
 
             match = if node.block_type?
                       block_argument = argument.children.first.source

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

@@ -51,7 +51,7 @@ module RuboCop
         private
 
         def offense_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/presence.rb

@@ -93,7 +93,7 @@ module RuboCop
 
         def register_offense(node, receiver, other)
           add_offense(node, message: message(node, receiver, other)) do |corrector|
-            corrector.replace(node.source_range, replacement(receiver, other, node.left_sibling))
+            corrector.replace(node, replacement(receiver, other, node.left_sibling))
           end
         end
 
@@ -112,10 +112,10 @@ module RuboCop
         end
 
         def current(node)
-          if node.source.include?("\n")
+          if !node.ternary? && node.source.include?("\n")
             "#{node.loc.keyword.with(end_pos: node.condition.loc.selector.end_pos).source} ... end"
           else
-            node.source
+            node.source.gsub(/\n\s*/, ' ')
           end
         end
 

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

@@ -8,7 +8,7 @@ module RuboCop
       #
       # Interaction with `Style/UnlessElse`:
       # The configuration of `NotBlank` will not produce an offense in the
-      # context of `unless else` if `Style/UnlessElse` is inabled. This is
+      # context of `unless else` if `Style/UnlessElse` is enabled. This is
       # to prevent interference between the autocorrection of the two cops.
       #
       # @example NotNilAndNotEmpty: true (default)
@@ -128,10 +128,10 @@ module RuboCop
 
           if method_call
             corrector.replace(node.loc.keyword, 'if')
-            range = method_call.loc.expression
+            range = method_call.source_range
           else
             variable1, _variable2 = exists_and_not_empty?(node) || not_blank?(node)
-            range = node.loc.expression
+            range = node.source_range
           end
 
           corrector.replace(range, replacement(variable1))
@@ -141,9 +141,9 @@ module RuboCop
 
         def unless_condition(node, method_call)
           if node.modifier_form?
-            node.loc.keyword.join(node.loc.expression.end)
+            node.loc.keyword.join(node.source_range.end)
           else
-            node.loc.expression.begin.join(method_call.loc.expression)
+            node.source_range.begin.join(method_call.source_range)
           end
         end
 

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

@@ -48,7 +48,7 @@ module RuboCop
               task_name = task_method.arguments[0]
               task_dependency = correct_task_dependency(task_name)
 
-              corrector.replace(task_name.loc.expression, task_dependency)
+              corrector.replace(task_name, task_dependency)
             end
           end
         end

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

@@ -52,7 +52,7 @@ module RuboCop
           return if within_shadowing_method?(node)
 
           add_offense(node, message: build_message(node)) do |corrector|
-            corrector.replace(node.source_range, node_replacement(node))
+            corrector.replace(node, node_replacement(node))
           end
         end
 

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

@@ -62,7 +62,7 @@ module RuboCop
             elsif prv_sib
               corrector.remove(range_between(node_end(prv_sib), node_end(allow_nil)))
             else
-              corrector.remove(allow_nil.loc.expression)
+              corrector.remove(allow_nil)
             end
           end
         end
@@ -87,11 +87,11 @@ module RuboCop
         end
 
         def node_beg(node)
-          node.loc.expression.begin_pos
+          node.source_range.begin_pos
         end
 
         def node_end(node)
-          node.loc.expression.end_pos
+          node.source_range.end_pos
         end
       end
     end

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

@@ -40,7 +40,7 @@ module RuboCop
         def on_send(node)
           association_with_foreign_key(node) do |type, name, options, foreign_key_pair, foreign_key|
             if redundant?(node, type, name, options, foreign_key)
-              add_offense(foreign_key_pair.loc.expression) do |corrector|
+              add_offense(foreign_key_pair.source_range) do |corrector|
                 range = range_with_surrounding_space(foreign_key_pair.source_range, side: :left)
                 range = range_with_surrounding_comma(range, :left)
 

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

@@ -89,7 +89,7 @@ module RuboCop
         private
 
         def autocorrect(corrector, send_node, node)
-          corrector.remove(send_node.receiver.source_range)
+          corrector.remove(send_node.receiver)
           corrector.remove(send_node.loc.dot)
           corrector.remove(block_argument_range(send_node)) unless node.numblock_type?
         end

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

@@ -18,6 +18,8 @@ module RuboCop
       #   # good
       #   has_many :accounts, class_name: 'Account'
       class ReflectionClassName < Base
+        extend AutoCorrector
+
         MSG = 'Use a string value for `class_name`.'
         RESTRICT_ON_SEND = %i[has_many has_one belongs_to].freeze
         ALLOWED_REFLECTION_CLASS_TYPES = %i[dstr str sym].freeze
@@ -32,12 +34,18 @@ module RuboCop
           (pair (sym :class_name) #reflection_class_value?)
         PATTERN
 
+        def_node_matcher :const_or_string, <<~PATTERN
+          {$(const nil? _) (send $(const nil? _) :name) (send $(const nil? _) :to_s)}
+        PATTERN
+
         def on_send(node)
           association_with_reflection(node) do |reflection_class_name|
             return if reflection_class_name.value.send_type? && reflection_class_name.value.receiver.nil?
             return if reflection_class_name.value.lvar_type? && str_assigned?(reflection_class_name)
 
-            add_offense(reflection_class_name.loc.expression)
+            add_offense(reflection_class_name.source_range) do |corrector|
+              autocorrect(corrector, reflection_class_name)
+            end
           end
         end
 
@@ -64,6 +72,14 @@ module RuboCop
             !ALLOWED_REFLECTION_CLASS_TYPES.include?(class_value.type)
           end
         end
+
+        def autocorrect(corrector, class_config)
+          class_value = class_config.value
+          replacement = const_or_string(class_value)
+          return unless replacement.present?
+
+          corrector.replace(class_value, replacement.source.inspect)
+        end
       end
     end
   end

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

@@ -78,7 +78,7 @@ module RuboCop
           indent = ' ' * node.loc.column
           new_code = ["def self.#{const_name.downcase}", "#{indent}#{value.source}", 'end'].join("\n#{indent}")
 
-          corrector.replace(node.source_range, new_code)
+          corrector.replace(node, new_code)
         end
 
         def message(method_name)
@@ -86,7 +86,7 @@ module RuboCop
         end
 
         def offense_range(name, value)
-          range_between(name.loc.expression.begin_pos, value.loc.expression.end_pos)
+          range_between(name.source_range.begin_pos, value.source_range.end_pos)
         end
 
         def nested_relative_date(node, &callback)