rubocop-rails 2.13.0 → 2.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f12ec262c68bd72f514b80f2140b51278a947f21726ef6307e6267eaec7df4ae
-  data.tar.gz: 2a09b4db338465d1904a19e8d4af871ba485e75244613299fabe473854125e4c
+  metadata.gz: 624c6bfb8dc9c5db0f6dd6bec835bd71e5e5a7aadc298342c15faae187226079
+  data.tar.gz: 4354d39a8367f0e4cb46b5a890cdd0836bfff6d838b5ae320b3df3a480f529af
 SHA512:
-  metadata.gz: fbf73dc2e978bc210e2dc190b8042720f24e6e374962b2873e6c29ec989ed2a7c1b05646c22a38d57f28e753104ac40a0e592730e63703d99dbb80fc6b498651
-  data.tar.gz: b70e78355a3fa5b09f3a2a1603c71b16547c3f2f80c0ce7c2dbbc3c38cae0a0ca9464a50895eb54ac8ccd558c9259bf28a1e4ebebb9e3d4f05102832f178fc11
+  metadata.gz: 19863e8b5b71b4403d66b46e73ed41ceb1953d2a68996fbcc800ab4c06fcf4dfebadf3907f62d2c575b002223a95fa67fce2412c01fa42b6234848c2791b37e9
+  data.tar.gz: 1e3d14e3240f7fdb9182529865ee8257cf19368bac19c33abfba44b0a3b63c54e64457f73725e6c629a5846ea402a96e650f7d6ce0e1943386c857d6a8642d7b

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-21 Bozhidar Batsov
+Copyright (c) 2012-22 Bozhidar Batsov
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

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/read_write_attribute.rb

@@ -23,6 +23,17 @@ 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
 
@@ -38,6 +49,7 @@ 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
@@ -53,6 +65,15 @@ module RuboCop
 
         private
 
+        def within_shadowing_method?(node)
+          node.each_ancestor(:def).any? do |enclosing_method|
+            shadowing_method_name = node.first_argument.value.to_s
+            shadowing_method_name << '=' if node.method?(:write_attribute)
+
+            enclosing_method.method_name.to_s == shadowing_method_name
+          end
+        end
+
         def message(node)
           if node.method?(:read_attribute)
             format(MSG, prefer: 'self[:attr]', current: 'read_attribute(:attr)')

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

@@ -32,7 +32,7 @@ module RuboCop
         extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Remove explicit presence validation for `%<association>s`.'
+        MSG = 'Remove explicit presence validation for %<association>s.'
         RESTRICT_ON_SEND = %i[validates].freeze
 
         minimum_target_rails_version 5.0
@@ -43,28 +43,39 @@ module RuboCop
         #   @example source that matches - by association
         #     validates :user, presence: true
         #
+        #   @example source that matches - by association
+        #     validates :name, :user, presence: true
+        #
         #   @example source that matches - with presence options
         #     validates :user, presence: { message: 'duplicate' }
         #
         #   @example source that matches - by a foreign key
         #     validates :user_id, presence: true
+        #
+        #   @example source that DOES NOT match - strict validation
+        #     validates :user_id, presence: true, strict: true
+        #
+        #   @example source that DOES NOT match - custom strict validation
+        #     validates :user_id, presence: true, strict: MissingUserError
         def_node_matcher :presence_validation?, <<~PATTERN
-          $(
+          (
             send nil? :validates
-            (sym $_)
-            ...
-            $(hash <$(pair (sym :presence) {true hash}) ...>)
+            (sym $_)+
+            $[
+              (hash <$(pair (sym :presence) {true hash}) ...>)  # presence: true
+              !(hash <$(pair (sym :strict) {true const}) ...>)  # strict: true
+            ]
           )
         PATTERN
 
-        # @!method optional_option?(node)
-        #  Match a `belongs_to` association with an optional option in a hash
+        # @!method optional?(node)
+        #   Match a `belongs_to` association with an optional option in a hash
         def_node_matcher :optional?, <<~PATTERN
           (send nil? :belongs_to _ ... #optional_option?)
         PATTERN
 
         # @!method optional_option?(node)
-        #  Match an optional option in a hash
+        #   Match an optional option in a hash
         def_node_matcher :optional_option?, <<~PATTERN
           {
             (hash <(pair (sym :optional) true) ...>)   # optional: true
@@ -122,7 +133,7 @@ module RuboCop
           )
         PATTERN
 
-        # @!method belongs_to_without_fk?(node, fk)
+        # @!method belongs_to_without_fk?(node, key)
         #   Match a matching `belongs_to` association, without an explicit `foreign_key` option
         #
         #   @param node [RuboCop::AST::Node]
@@ -150,21 +161,43 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          validation, key, options, presence = presence_validation?(node)
-          return unless validation
+          presence_validation?(node) do |all_keys, options, presence|
+            keys = non_optional_belongs_to(node.parent, all_keys)
+            return if keys.none?
 
-          belongs_to = belongs_to_for(node.parent, key)
-          return unless belongs_to
-          return if optional?(belongs_to)
+            add_offense_and_correct(node, all_keys, keys, options, presence)
+          end
+        end
 
-          message = format(MSG, association: key.to_s)
+        private
 
-          add_offense(presence, message: message) do |corrector|
-            remove_presence_validation(corrector, node, options, presence)
+        def add_offense_and_correct(node, all_keys, keys, options, presence)
+          add_offense(presence, message: message_for(keys)) do |corrector|
+            if options.children.one? # `presence: true` is the only option
+              if keys == all_keys
+                remove_validation(corrector, node)
+              else
+                remove_keys_from_validation(corrector, node, keys)
+              end
+            elsif keys == all_keys
+              remove_presence_option(corrector, presence)
+            else
+              extract_validation_for_keys(corrector, node, keys, options)
+            end
           end
         end
 
-        private
+        def message_for(keys)
+          display_keys = keys.map { |key| "`#{key}`" }.join('/')
+          format(MSG, association: display_keys)
+        end
+
+        def non_optional_belongs_to(node, keys)
+          keys.select do |key|
+            belongs_to = belongs_to_for(node, key)
+            belongs_to && !optional?(belongs_to)
+          end
+        end
 
         def belongs_to_for(model_class_node, key)
           if key.to_s.end_with?('_id')
@@ -175,17 +208,48 @@ module RuboCop
           end
         end
 
-        def remove_presence_validation(corrector, node, options, presence)
-          if options.children.one?
-            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
-          else
-            range = range_with_surrounding_comma(
-              range_with_surrounding_space(range: presence.source_range, side: :left),
-              :left
+        def remove_validation(corrector, node)
+          corrector.remove(validation_range(node))
+        end
+
+        def remove_keys_from_validation(corrector, node, keys)
+          keys.each do |key|
+            key_node = node.arguments.find { |arg| arg.value == key }
+            key_range = range_with_surrounding_space(
+              range: range_with_surrounding_comma(key_node.source_range, :right),
+              side: :right
             )
-            corrector.remove(range)
+            corrector.remove(key_range)
           end
         end
+
+        def remove_presence_option(corrector, presence)
+          range = range_with_surrounding_comma(
+            range_with_surrounding_space(range: presence.source_range, side: :left),
+            :left
+          )
+          corrector.remove(range)
+        end
+
+        def extract_validation_for_keys(corrector, node, keys, options)
+          indentation = ' ' * node.source_range.column
+          options_without_presence = options.children.reject { |pair| pair.key.value == :presence }
+          source = [
+            indentation,
+            'validates ',
+            keys.map(&:inspect).join(', '),
+            ', ',
+            options_without_presence.map(&:source).join(', '),
+            "\n"
+          ].join
+
+          remove_keys_from_validation(corrector, node, keys)
+          corrector.insert_after(validation_range(node), source)
+        end
+
+        def validation_range(node)
+          range_by_whole_lines(node.source_range, include_final_newline: true)
+        end
       end
     end
   end

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

@@ -179,7 +179,7 @@ module RuboCop
         MSG = '%<action>s is not reversible.'
 
         def_node_matcher :irreversible_schema_statement_call, <<~PATTERN
-          (send nil? ${:change_column :execute :remove_belongs_to :remove_reference} ...)
+          (send nil? ${:change_column :execute} ...)
         PATTERN
 
         def_node_matcher :drop_table_call, <<~PATTERN

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

@@ -61,6 +61,8 @@ module RuboCop
 
         def table(node)
           klass = class_node(node)
+          return unless klass
+
           schema.table_by(name: table_name(klass))
         end
       end

data/lib/rubocop/rails/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Rails
     # This module holds the RuboCop Rails version information.
     module Version
-      STRING = '2.13.0'
+      STRING = '2.13.1'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rails
 version: !ruby/object:Gem::Version
-  version: 2.13.0
+  version: 2.13.1
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-25 00:00:00.000000000 Z
+date: 2022-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -212,7 +212,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Automatic Rails code style checking tool.