rubocop 0.52.0 → 0.52.1

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

@@ -38,9 +38,10 @@ module RuboCop
       #       something
       #     end
       class Blank < Cop
-        MSG_NIL_OR_EMPTY = 'Use `%s` instead of `%s`.'.freeze
-        MSG_NOT_PRESENT = 'Use `%s` instead of `%s`.'.freeze
-        MSG_UNLESS_PRESENT = 'Use `if %s` instead of `%s`.'.freeze
+        MSG_NIL_OR_EMPTY = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
+        MSG_NOT_PRESENT = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
+        MSG_UNLESS_PRESENT = 'Use `if %<prefer>s` instead of ' \
+                             '`%<current>s`.'.freeze
 
         # `(send nil $_)` is not actually a valid match for an offense. Nodes
         # that have a single method call on the left hand side
@@ -73,8 +74,8 @@ module RuboCop
           not_present?(node) do |receiver|
             add_offense(node,
                         message: format(MSG_NOT_PRESENT,
-                                        replacement(receiver),
-                                        node.source))
+                                        prefer: replacement(receiver),
+                                        current: node.source))
           end
         end
 
@@ -86,8 +87,8 @@ module RuboCop
 
             add_offense(node,
                         message: format(MSG_NIL_OR_EMPTY,
-                                        replacement(variable1),
-                                        node.source))
+                                        prefer: replacement(variable1),
+                                        current: node.source))
           end
         end
 
@@ -101,8 +102,8 @@ module RuboCop
             add_offense(node,
                         location: range,
                         message: format(MSG_UNLESS_PRESENT,
-                                        replacement(receiver),
-                                        range.source))
+                                        prefer: replacement(receiver),
+                                        current: range.source))
           end
         end
 

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

@@ -20,27 +20,37 @@ module RuboCop
       # When EnforcedStyle is 'flexible' then only 'Date.today' is prohibited
       # and only 'to_time' is reported as warning.
       #
-      # @example
-      #   # no offense
-      #   Time.zone.today
-      #   Time.zone.today - 1.day
-      #
-      #   # flexible
+      # @example EnforcedStyle: strict
+      #   # bad
       #   Date.current
       #   Date.yesterday
+      #   Date.today
+      #   date.to_time
+      #   date.to_time_in_current_zone
+      #
+      #   # good
+      #   Time.zone.today
+      #   Time.zone.today - 1.day
       #
-      #   # always reports offense
+      # @example EnforcedStyle: flexible (default)
+      #   # bad
       #   Date.today
       #   date.to_time
       #
-      #   # reports offense only when style is 'strict'
+      #   # good
+      #   Time.zone.today
+      #   Time.zone.today - 1.day
+      #   Date.current
+      #   Date.yesterday
       #   date.to_time_in_current_zone
+      #
       class Date < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Do not use `%s` without zone. Use `%s` instead.'.freeze
+        MSG = 'Do not use `Date.%<day>s` without zone. Use ' \
+              '`Time.zone.%<day>s` instead.'.freeze
 
-        MSG_SEND = 'Do not use `%s` on Date objects, because they ' \
+        MSG_SEND = 'Do not use `%<method>s` on Date objects, because they ' \
                    'know nothing about the time zone in use.'.freeze
 
         BAD_DAYS = %i[today current yesterday tomorrow].freeze
@@ -59,7 +69,7 @@ module RuboCop
           return if safe_chain?(node) || safe_to_time?(node)
 
           add_offense(node, location: :selector,
-                            message: format(MSG_SEND, node.method_name))
+                            message: format(MSG_SEND, method: node.method_name))
         end
 
         private
@@ -72,9 +82,7 @@ module RuboCop
           method_name = (chain & bad_days).join('.')
 
           add_offense(node, location: :selector,
-                            message: format(MSG,
-                                            "Date.#{method_name}",
-                                            "Time.zone.#{method_name}"))
+                            message: format(MSG, day: method_name.to_s))
         end
 
         def extract_method_chain(node)

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

@@ -112,7 +112,7 @@ module RuboCop
         end
 
         def private_or_protected_delegation(node)
-          line = node.loc.line
+          line = node.first_line
           private_or_protected_before(line) ||
             private_or_protected_inline(line)
         end

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

@@ -26,7 +26,7 @@ module RuboCop
       #   # good
       #   User.find_by!(email: email)
       class DynamicFindBy < Cop
-        MSG = 'Use `%s` instead of dynamic `%s`.'.freeze
+        MSG = 'Use `%<static_name>s` instead of dynamic `%<method>s`.'.freeze
         METHOD_PATTERN = /^find_by_(.+?)(!)?$/
 
         def on_send(node)
@@ -39,7 +39,8 @@ module RuboCop
           return unless static_name
 
           add_offense(node,
-                      message: format(MSG, static_name, node.method_name))
+                      message: format(MSG, static_name: static_name,
+                                           method: node.method_name))
         end
 
         def autocorrect(node)

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

@@ -20,7 +20,8 @@ module RuboCop
       class EnumUniqueness < Cop
         include Duplication
 
-        MSG = 'Duplicate value `%s` found in `%s` enum declaration.'.freeze
+        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` ' \
+              'enum declaration.'.freeze
 
         def_node_matcher :enum_declaration, <<-PATTERN
           (send nil? :enum (hash (pair (_ $_) ${array hash})))
@@ -33,7 +34,8 @@ module RuboCop
             return unless duplicates?(items)
 
             consecutive_duplicates(items).each do |item|
-              add_offense(item, message: format(MSG, item.source, name))
+              add_offense(item, message: format(MSG, value: item.source,
+                                                     enum: name))
             end
           end
         end

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

@@ -16,7 +16,7 @@ module RuboCop
       #   # good
       #   Rails.env.production?
       class EnvironmentComparison < Cop
-        MSG = 'Favor `Rails.env.%s?` over `Rails.env == %s`.'.freeze
+        MSG = "Favor `Rails.env.%<env>s?` over `Rails.env == '%<env>s'`.".freeze
 
         SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always ' \
           'evaluate to `false`.'.freeze
@@ -40,7 +40,7 @@ module RuboCop
         def on_send(node)
           environment_str_comparison?(node) do |env_node|
             env, = *env_node
-            add_offense(node, message: format(MSG, env, env_node.source))
+            add_offense(node, message: format(MSG, env: env))
           end
           environment_sym_comparison?(node) do |_|
             add_offense(node, message: SYM_MSG)

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

@@ -62,7 +62,7 @@ module RuboCop
 
         def register_offense(node)
           line_range = node.loc.column...node.loc.last_column
-          source_range = source_range(processed_source.buffer, node.loc.line,
+          source_range = source_range(processed_source.buffer, node.first_line,
                                       line_range)
           add_offense(node, location: source_range)
         end

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

@@ -14,7 +14,7 @@ module RuboCop
       #   # good
       #   User.find_by(name: 'Bruce')
       class FindBy < Cop
-        MSG = 'Use `find_by` instead of `where.%s`.'.freeze
+        MSG = 'Use `find_by` instead of `where.%<method>s`.'.freeze
         TARGET_SELECTORS = %i[first take].freeze
 
         def_node_matcher :where_first?, <<-PATTERN
@@ -28,7 +28,7 @@ module RuboCop
                                 node.loc.selector.end_pos)
 
           add_offense(node, location: range,
-                            message: format(MSG, node.method_name))
+                            message: format(MSG, method: node.method_name))
         end
 
         def autocorrect(node)

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

@@ -47,21 +47,29 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          if !association_without_options?(node)
+          unless association_without_options?(node)
             return if valid_options?(association_with_options?(node))
-          else
-            n = node.parent.begin_type? ? node.parent.parent : node.parent
-
-            if with_options_block(n)
-              return if valid_options?(with_options_block(n))
-            end
           end
 
+          return if valid_options_in_with_options_block?(node)
+
           add_offense(node, location: :selector)
         end
 
         private
 
+        def valid_options_in_with_options_block?(node)
+          return true unless node.parent
+
+          n = node.parent.begin_type? ? node.parent.parent : node.parent
+
+          if with_options_block(n)
+            return true if valid_options?(with_options_block(n))
+          end
+
+          false
+        end
+
         def valid_options?(options)
           return true unless options
           return true if options.any? do |o|

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

@@ -20,7 +20,7 @@ module RuboCop
         extend TargetRailsVersion
 
         MSG = 'Use keyword arguments instead of ' \
-              'positional arguments for http call: `%s`.'.freeze
+              'positional arguments for http call: `%<verb>s`.'.freeze
         KEYWORD_ARGS = %i[
           headers env params body flash as xhr session method
         ].freeze
@@ -37,7 +37,7 @@ module RuboCop
             return unless needs_conversion?(data)
 
             add_offense(node, location: :selector,
-                              message: format(MSG, node.method_name))
+                              message: format(MSG, verb: node.method_name))
           end
         end
 

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

@@ -10,19 +10,109 @@ module RuboCop
       # for associations to work in both ways, or set to `false` to opt-out.
       #
       # @example
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     has_many :posts
+      #   end
+      #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
+      #   end
+      #
+      # @example
       #   # bad
       #   class Blog < ApplicationRecord
-      #     has_many :recent_posts, -> { order(published_at: :desc) }
+      #     has_many :posts, -> { order(published_at: :desc) }
+      #   end
+      #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
       #   end
       #
       #   # good
       #   class Blog < ApplicationRecord
-      #     has_many(:recent_posts,
+      #     has_many(:posts,
       #       -> { order(published_at: :desc) },
       #       inverse_of: :blog
       #     )
       #   end
       #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
+      #   end
+      #
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     with_options inverse_of: :blog do
+      #       has_many :posts, -> { order(published_at: :desc) }
+      #     end
+      #   end
+      #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
+      #   end
+      #
+      # @example
+      #   # bad
+      #   class Picture < ApplicationRecord
+      #     belongs_to :imageable, polymorphic: true
+      #   end
+      #
+      #   class Employee < ApplicationRecord
+      #     has_many :pictures, as: :imageable
+      #   end
+      #
+      #   class Product < ApplicationRecord
+      #     has_many :pictures, as: :imageable
+      #   end
+      #
+      #   # good
+      #   class Picture < ApplicationRecord
+      #     belongs_to :imageable, polymorphic: true
+      #   end
+      #
+      #   class Employee < ApplicationRecord
+      #     has_many :pictures, as: :imageable, inverse_of: :imageable
+      #   end
+      #
+      #   class Product < ApplicationRecord
+      #     has_many :pictures, as: :imageable, inverse_of: :imageable
+      #   end
+      #
+      # @example
+      #   # bad
+      #   # However, RuboCop can not detect this pattern...
+      #   class Physician < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :patients, through: :appointments
+      #   end
+      #
+      #   class Appointment < ApplicationRecord
+      #     belongs_to :physician
+      #     belongs_to :patient
+      #   end
+      #
+      #   class Patient < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :physicians, through: :appointments
+      #   end
+      #
+      #   # good
+      #   class Physician < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :patients, through: :appointments
+      #   end
+      #
+      #   class Appointment < ApplicationRecord
+      #     belongs_to :physician, inverse_of: :appointments
+      #     belongs_to :patient, inverse_of: :appointments
+      #   end
+      #
+      #   class Patient < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :physicians, through: :appointments
+      #   end
+      #
       # @see http://guides.rubyonrails.org/association_basics.html#bi-directional-associations
       # @see http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Setting+Inverses
       class InverseOf < Cop
@@ -32,8 +122,8 @@ module RuboCop
 
         MSG = 'Specify an `:inverse_of` option.'.freeze
 
-        def_node_matcher :association_arguments, <<-PATTERN
-          (send nil? {:has_many :has_one :belongs_to} _ $...)
+        def_node_matcher :association_recv_arguments, <<-PATTERN
+          (send $_ {:has_many :has_one :belongs_to} _ $...)
         PATTERN
 
         def_node_matcher :options_from_argument, <<-PATTERN
@@ -52,6 +142,14 @@ module RuboCop
           (pair (sym :polymorphic) !nil)
         PATTERN
 
+        def_node_matcher :as_option?, <<-PATTERN
+          (pair (sym :as) !nil)
+        PATTERN
+
+        def_node_matcher :class_name_option?, <<-PATTERN
+          (pair (sym :class_name) !nil)
+        PATTERN
+
         def_node_matcher :foreign_key_option?, <<-PATTERN
           (pair (sym :foreign_key) !nil)
         PATTERN
@@ -61,10 +159,15 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          arguments = association_arguments(node)
+          recv, arguments = association_recv_arguments(node)
           return unless arguments
+          with_options = with_options_arguments(recv, node)
+
+          options = arguments.concat(with_options).flat_map do |arg|
+            options_from_argument(arg)
+          end
+          return if options_ignoring_inverse_of?(options)
 
-          options = arguments.flat_map { |arg| options_from_argument(arg) }
           return unless scope?(arguments) ||
                         options_requiring_inverse_of?(options)
 
@@ -79,17 +182,36 @@ module RuboCop
         def options_requiring_inverse_of?(options)
           required = options.any? do |opt|
             conditions_option?(opt) ||
-              through_option?(opt) ||
+              class_name_option?(opt) ||
               foreign_key_option?(opt)
           end
 
           return required if target_rails_version >= 5.2
-          required || options.any? { |opt| polymorphic_option?(opt) }
+          required || options.any? { |opt| as_option?(opt) }
+        end
+
+        def options_ignoring_inverse_of?(options)
+          options.any? do |opt|
+            through_option?(opt) || polymorphic_option?(opt)
+          end
         end
 
         def options_contain_inverse_of?(options)
           options.any? { |opt| inverse_of_option?(opt) }
         end
+
+        def with_options_arguments(recv, node)
+          blocks = node.each_ancestor(:block).select do |block|
+            block.send_node.command?(:with_options) &&
+              same_context_in_with_options?(block.arguments.first, recv)
+          end
+          blocks.flat_map { |n| n.send_node.arguments }
+        end
+
+        def same_context_in_with_options?(arg, recv)
+          return true if arg.nil? && recv.nil?
+          arg && recv && arg.children[0] == recv.children[0]
+        end
       end
     end
   end