rubocop 0.49.1 → 0.52.0

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

@@ -20,25 +20,15 @@ module RuboCop
 
         def_node_matcher :read_write_attribute?, <<-PATTERN
           {
-            (send nil :read_attribute _)
-            (send nil :write_attribute _ _)
+            (send nil? :read_attribute _)
+            (send nil? :write_attribute _ _)
           }
         PATTERN
 
         def on_send(node)
           return unless read_write_attribute?(node)
 
-          add_offense(node, :selector)
-        end
-
-        private
-
-        def message(node)
-          if node.method?(:read_attribute)
-            format(MSG, 'self[:attr]', 'read_attribute(:attr)')
-          else
-            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
-          end
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
@@ -52,6 +42,16 @@ module RuboCop
           ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
+        private
+
+        def message(node)
+          if node.method?(:read_attribute)
+            format(MSG, 'self[:attr]', 'read_attribute(:attr)')
+          else
+            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
+          end
+        end
+
         def read_attribute_replacement(node)
           "self[#{node.first_argument.source}]"
         end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for redundant receiver in `with_options`.
+      # Receiver is implicit from Rails 4.2 or higher.
+      #
+      # @example
+      #   # bad
+      #   class Account < ApplicationRecord
+      #     with_options dependent: :destroy do |assoc|
+      #       assoc.has_many :customers
+      #       assoc.has_many :products
+      #       assoc.has_many :invoices
+      #       assoc.has_many :expenses
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Account < ApplicationRecord
+      #     with_options dependent: :destroy do
+      #       has_many :customers
+      #       has_many :products
+      #       has_many :invoices
+      #       has_many :expenses
+      #     end
+      #   end
+      class RedundantReceiverInWithOptions < Cop
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 4.2
+
+        MSG = 'Redundant receiver in `with_options`.'.freeze
+
+        def_node_matcher :with_options?, <<-PATTERN
+          (block
+            (send nil? :with_options
+              (...))
+            (args
+              (...))
+            ...)
+        PATTERN
+
+        def_node_search :assoc_has_redundant_receiver, <<-PATTERN
+          (send
+            (lvar _) ...)
+        PATTERN
+
+        def on_block(node)
+          with_options?(node) do
+            assoc_has_redundant_receiver(node).each do |assoc|
+              add_offense(assoc, location: assoc.receiver.loc.expression)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.receiver.loc.expression)
+            corrector.remove(node.loc.dot)
+            corrector.remove(block_argument_range(node))
+          end
+        end
+
+        private
+
+        def block_argument_range(node)
+          block_argument = node.parent.parent.children[1].loc.expression
+
+          range_between(
+            search_begin_pos_of_space_before_block_argument(
+              block_argument.begin_pos
+            ),
+            block_argument.end_pos
+          )
+        end
+
+        def search_begin_pos_of_space_before_block_argument(begin_pos)
+          position = begin_pos - 1
+
+          if processed_source.raw_source[position] == ' '
+            search_begin_pos_of_space_before_block_argument(position)
+          else
+            begin_pos
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -51,6 +51,15 @@ module RuboCop
           check_node(rhs)
         end
 
+        def autocorrect(node)
+          _scope, const_name, value = *node
+          indent = ' ' * node.loc.column
+          new_code = ["def self.#{const_name.downcase}",
+                      "#{indent}#{value.source}",
+                      'end'].join("\n#{indent}")
+          ->(corrector) { corrector.replace(node.source_range, new_code) }
+        end
+
         private
 
         def check_node(node)
@@ -63,7 +72,7 @@ module RuboCop
 
           nodes.each do |n|
             if relative_date_method?(n)
-              add_offense(node.parent, :expression, format(MSG, n.method_name))
+              add_offense(node.parent, message: format(MSG, n.method_name))
             end
           end
         end
@@ -71,16 +80,7 @@ module RuboCop
         def relative_date_method?(node)
           node.send_type? &&
             RELATIVE_DATE_METHODS.include?(node.method_name) &&
-            node.method_args.empty?
-        end
-
-        def autocorrect(node)
-          _scope, const_name, value = *node
-          indent = ' ' * node.loc.column
-          new_code = ["def self.#{const_name.downcase}",
-                      "#{indent}#{value.source}",
-                      'end'].join("\n#{indent}")
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
+            !node.arguments?
         end
       end
     end

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

@@ -26,14 +26,14 @@ module RuboCop
         MSG = 'Use `request.%s` instead of `request.%s`.'.freeze
 
         def_node_matcher :referer?, <<-PATTERN
-          (send (send nil :request) {:referer :referrer})
+          (send (send nil? :request) {:referer :referrer})
         PATTERN
 
         def on_send(node)
           referer?(node) do
             return unless node.method?(wrong_method_name)
 
-            add_offense(node.source_range, node.source_range, message)
+            add_offense(node.source_range, location: node.source_range)
           end
         end
 
@@ -43,7 +43,7 @@ module RuboCop
 
         private
 
-        def message
+        def message(_node)
           format(MSG, style, wrong_method_name)
         end
 

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

@@ -131,29 +131,29 @@ module RuboCop
           change change_default remove
         ].freeze
 
-        def_node_matcher :irreversible_schema_statement_call, <<-END
-          (send nil ${:change_table_comment :execute :remove_belongs_to} ...)
-        END
+        def_node_matcher :irreversible_schema_statement_call, <<-PATTERN
+          (send nil? ${:change_table_comment :execute :remove_belongs_to} ...)
+        PATTERN
 
-        def_node_matcher :drop_table_call, <<-END
-          (send nil :drop_table ...)
-        END
+        def_node_matcher :drop_table_call, <<-PATTERN
+          (send nil? :drop_table ...)
+        PATTERN
 
-        def_node_matcher :change_column_default_call, <<-END
-          (send nil :change_column_default _ _ $...)
-        END
+        def_node_matcher :change_column_default_call, <<-PATTERN
+          (send nil? :change_column_default _ _ $...)
+        PATTERN
 
-        def_node_matcher :remove_column_call, <<-END
-          (send nil :remove_column $...)
-        END
+        def_node_matcher :remove_column_call, <<-PATTERN
+          (send nil? :remove_column $...)
+        PATTERN
 
-        def_node_matcher :remove_foreign_key_call, <<-END
-          (send nil :remove_foreign_key _ $_)
-        END
+        def_node_matcher :remove_foreign_key_call, <<-PATTERN
+          (send nil? :remove_foreign_key _ $_)
+        PATTERN
 
-        def_node_matcher :change_table_call, <<-END
-          (send nil :change_table $_ ...)
-        END
+        def_node_matcher :change_table_call, <<-PATTERN
+          (send nil? :change_table $_ ...)
+        PATTERN
 
         def on_send(node)
           return unless within_change_method?(node)
@@ -177,7 +177,7 @@ module RuboCop
 
         def check_irreversible_schema_statement_node(node)
           irreversible_schema_statement_call(node) do |method_name|
-            add_offense(node, :expression, format(MSG, method_name))
+            add_offense(node, message: format(MSG, method_name))
           end
         end
 
@@ -185,8 +185,8 @@ module RuboCop
           drop_table_call(node) do
             unless node.parent.block_type?
               add_offense(
-                node, :expression,
-                format(MSG, 'drop_table(without block)')
+                node,
+                message: format(MSG, 'drop_table(without block)')
               )
             end
           end
@@ -196,8 +196,10 @@ module RuboCop
           change_column_default_call(node) do |args|
             unless all_hash_key?(args.first, :from, :to)
               add_offense(
-                node, :expression,
-                format(MSG, 'change_column_default(without :from and :to)')
+                node,
+                message: format(
+                  MSG, 'change_column_default(without :from and :to)'
+                )
               )
             end
           end
@@ -207,8 +209,8 @@ module RuboCop
           remove_column_call(node) do |args|
             if args.to_a.size < 3
               add_offense(
-                node, :expression,
-                format(MSG, 'remove_column(without type)')
+                node,
+                message: format(MSG, 'remove_column(without type)')
               )
             end
           end
@@ -218,8 +220,8 @@ module RuboCop
           remove_foreign_key_call(node) do |arg|
             if arg.hash_type?
               add_offense(
-                node, :expression,
-                format(MSG, 'remove_foreign_key(without table)')
+                node,
+                message: format(MSG, 'remove_foreign_key(without table)')
               )
             end
           end
@@ -229,8 +231,8 @@ module RuboCop
           change_table_call(node) do |arg|
             if target_rails_version < 4.0
               add_offense(
-                node, :expression,
-                format(MSG, 'change_table')
+                node,
+                message: format(MSG, 'change_table')
               )
             elsif block.send_type?
               check_change_table_offense(arg, block)
@@ -247,15 +249,14 @@ module RuboCop
           return if receiver != node.receiver &&
                     !IRREVERSIBLE_CHANGE_TABLE_CALLS.include?(method_name)
           add_offense(
-            node, :expression,
-            format(MSG, "change_table(with #{method_name})")
+            node,
+            message: format(MSG, "change_table(with #{method_name})")
           )
         end
 
         def within_change_method?(node)
           node.each_ancestor(:def).any? do |ancestor|
-            method_name, = *ancestor
-            method_name == :change
+            ancestor.method?(:change)
           end
         end
 
@@ -268,8 +269,8 @@ module RuboCop
         def all_hash_key?(args, *keys)
           return false unless args && args.hash_type?
 
-          hash_keys = args.to_a.map do |arg|
-            arg.to_a.first.children.first.to_sym
+          hash_keys = args.keys.map do |key|
+            key.children.first.to_sym
           end
 
           hash_keys & keys == keys

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

@@ -45,23 +45,20 @@ module RuboCop
         MSG = 'Use safe navigation (`&.`) instead of `%s`.'.freeze
 
         def_node_matcher :try_call, <<-PATTERN
-          (send !nil ${:try :try!} $_ ...)
+          (send !nil? ${:try :try!} $_ ...)
         PATTERN
 
         minimum_target_ruby_version 2.3
 
         def on_send(node)
-          try_call(node) do |try_method, method_to_try|
+          try_call(node) do |try_method, dispatch|
             return if try_method == :try && !cop_config['ConvertTry']
-            return unless method_to_try.sym_type?
-            method, = *method_to_try
-            return unless method =~ /\w+[=!?]?/
-            add_offense(node, :expression, format(MSG, try_method))
+            return unless dispatch.sym_type? && dispatch.value =~ /\w+[=!?]?/
+
+            add_offense(node, message: format(MSG, try_method))
           end
         end
 
-        private
-
         def autocorrect(node)
           method_node, *params = *node.arguments
           method = method_node.source[1..-1]
@@ -74,6 +71,8 @@ module RuboCop
           end
         end
 
+        private
+
         def replacement(method, params)
           new_params = params.map(&:source).join(', ')
 

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

@@ -24,7 +24,7 @@ module RuboCop
       #
       #   # good
       #   unless user.save
-      #      . . .
+      #     # ...
       #   end
       #   user.save!
       #   user.update!(name: 'Joe')
@@ -33,7 +33,7 @@ module RuboCop
       #
       #   user = User.find_or_create_by(name: 'Joe')
       #   unless user.persisted?
-      #      . . .
+      #     # ...
       #   end
       class SaveBang < Cop
         MSG = 'Use `%s` instead of `%s` if the return value is not checked.'
@@ -56,7 +56,7 @@ module RuboCop
         end
 
         def after_leaving_scope(scope, _variable_table)
-          scope.variables.each do |_name, variable|
+          scope.variables.each_value do |variable|
             variable.assignments.each do |assignment|
               check_assignment(assignment)
             end
@@ -70,11 +70,11 @@ module RuboCop
           return unless expected_signature?(node)
           return if persisted_referenced?(assignment)
 
-          add_offense(node, node.loc.selector,
-                      format(CREATE_MSG,
-                             "#{node.method_name}!",
-                             node.method_name.to_s,
-                             node.method_name.to_s))
+          add_offense(node, location: :selector,
+                            message: format(CREATE_MSG,
+                                            "#{node.method_name}!",
+                                            node.method_name.to_s,
+                                            node.method_name.to_s))
         end
 
         def on_send(node)
@@ -84,10 +84,10 @@ module RuboCop
           return if check_used_in_conditional(node)
           return if last_call_of_method?(node)
 
-          add_offense(node, node.loc.selector,
-                      format(MSG,
-                             "#{node.method_name}!",
-                             node.method_name.to_s))
+          add_offense(node, location: :selector,
+                            message: format(MSG,
+                                            "#{node.method_name}!",
+                                            node.method_name.to_s))
         end
 
         def autocorrect(node)
@@ -121,17 +121,19 @@ module RuboCop
           return false unless conditional?(node)
 
           unless MODIFY_PERSIST_METHODS.include?(node.method_name)
-            add_offense(node, node.loc.selector,
-                        format(CREATE_CONDITIONAL_MSG,
-                               node.method_name.to_s))
+            add_offense(node, location: :selector,
+                              message: format(CREATE_CONDITIONAL_MSG,
+                                              node.method_name.to_s))
           end
 
           true
         end
 
         def conditional?(node)
-          node.parent && (node.parent.if_type? && node.sibling_index.zero? ||
-            conditional?(node.parent))
+          node.parent && (
+            node.parent.if_type? || node.parent.case_type? ||
+            node.parent.or_type? || node.parent.and_type?
+          )
         end
 
         def last_call_of_method?(node)