rubocop 0.50.0 → 0.51.0

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

@@ -58,7 +58,8 @@ module RuboCop
 
           return if safe_chain?(node) || safe_to_time?(node)
 
-          add_offense(node, :selector, format(MSG_SEND, node.method_name))
+          add_offense(node, location: :selector,
+                            message: format(MSG_SEND, node.method_name))
         end
 
         private
@@ -70,10 +71,10 @@ module RuboCop
 
           method_name = (chain & bad_days).join('.')
 
-          add_offense(node, :selector,
-                      format(MSG,
-                             "Date.#{method_name}",
-                             "Time.zone.#{method_name}"))
+          add_offense(node, location: :selector,
+                            message: format(MSG,
+                                            "Date.#{method_name}",
+                                            "Time.zone.#{method_name}"))
         end
 
         def extract_method_chain(node)
@@ -98,7 +99,7 @@ module RuboCop
           return unless node.method?(:to_time)
 
           if node.receiver.str_type?
-            zone_regexp = /[+-][\d:]+\z/
+            zone_regexp = /([+-][\d:]+|\dZ)\z/
 
             node.receiver.str_content.match(zone_regexp)
           else

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

@@ -59,7 +59,7 @@ module RuboCop
           method_name, args, body = *node
           return unless trivial_delegate?(method_name, args, body)
           return if private_or_protected_delegation(node)
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
 
         private

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

@@ -17,7 +17,7 @@ module RuboCop
         MSG = '`allow_blank` is not a valid option, use `allow_nil`.'.freeze
 
         def_node_matcher :delegate_options, <<-PATTERN
-          (send nil :delegate _ $hash)
+          (send nil? :delegate _ $hash)
         PATTERN
 
         def_node_matcher :allow_blank_option?, <<-PATTERN

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

@@ -38,8 +38,8 @@ module RuboCop
 
           return unless static_name
 
-          add_offense(node, :expression,
-                      format(MSG, static_name, node.method_name))
+          add_offense(node,
+                      message: format(MSG, static_name, node.method_name))
         end
 
         def autocorrect(node)

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

@@ -23,7 +23,7 @@ module RuboCop
         MSG = 'Duplicate value `%s` found in `%s` enum declaration.'.freeze
 
         def_node_matcher :enum_declaration, <<-PATTERN
-          (send nil :enum (hash (pair (_ $_) ${array hash})))
+          (send nil? :enum (hash (pair (_ $_) ${array hash})))
         PATTERN
 
         def on_send(node)
@@ -33,7 +33,7 @@ module RuboCop
             return unless duplicates?(items)
 
             consecutive_duplicates(items).each do |item|
-              add_offense(item, :expression, format(MSG, item.source, name))
+              add_offense(item, message: format(MSG, item.source, name))
             end
           end
         end

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

@@ -24,7 +24,7 @@ module RuboCop
         EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
 
         def on_send(node)
-          add_offense(node, :selector) if offending_node?(node)
+          add_offense(node, location: :selector) if offending_node?(node)
         end
 
         private

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

@@ -18,15 +18,15 @@ module RuboCop
         MSG = 'Please use `Rails.root.join(\'path\', \'to\')` instead.'.freeze
 
         def_node_matcher :file_join_nodes?, <<-PATTERN
-          (send (const nil :File) :join ...)
+          (send (const nil? :File) :join ...)
         PATTERN
 
         def_node_search :rails_root_nodes?, <<-PATTERN
-          (send (const nil :Rails) :root)
+          (send (const nil? :Rails) :root)
         PATTERN
 
         def_node_matcher :rails_root_join_nodes?, <<-PATTERN
-          (send (send (const nil :Rails) :root) :join ...)
+          (send (send (const nil? :Rails) :root) :join ...)
         PATTERN
 
         def on_dstr(node)
@@ -62,11 +62,9 @@ module RuboCop
 
         def register_offense(node)
           line_range = node.loc.column...node.loc.last_column
-
-          add_offense(
-            node,
-            source_range(processed_source.buffer, node.loc.line, line_range)
-          )
+          source_range = source_range(processed_source.buffer, node.loc.line,
+                                      line_range)
+          add_offense(node, location: source_range)
         end
       end
     end

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

@@ -27,7 +27,8 @@ module RuboCop
           range = range_between(node.receiver.loc.selector.begin_pos,
                                 node.loc.selector.end_pos)
 
-          add_offense(node, range, format(MSG, node.method_name))
+          add_offense(node, location: range,
+                            message: format(MSG, node.method_name))
         end
 
         def autocorrect(node)

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

@@ -24,7 +24,7 @@ module RuboCop
           return unless SCOPE_METHODS.include?(node.receiver.method_name)
           return if method_chain(node).any? { |m| ignored_by_find_each?(m) }
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)

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

@@ -10,7 +10,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:has_and_belongs_to_many)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -5,6 +5,7 @@ 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.
       #
       # @example
       #   # bad
@@ -17,30 +18,53 @@ module RuboCop
       #   class User < ActiveRecord::Base
       #     has_many :comments, dependent: :restrict_with_exception
       #     has_one :avatar, dependent: :destroy
+      #     has_many :patients, through: :appointments
       #   end
       class HasManyOrHasOneDependent < Cop
         MSG = 'Specify a `:dependent` option.'.freeze
 
-        def_node_matcher :is_has_many_or_has_one_without_options?, <<-PATTERN
-          (send nil {:has_many :has_one} _)
+        def_node_matcher :association_without_options?, <<-PATTERN
+          (send nil? {:has_many :has_one} _)
         PATTERN
 
-        def_node_matcher :is_has_many_or_has_one_with_options?, <<-PATTERN
-          (send nil {:has_many :has_one} _ (hash $...))
+        def_node_matcher :association_with_options?, <<-PATTERN
+          (send nil? {:has_many :has_one} _ (hash $...))
         PATTERN
 
-        def_node_matcher :has_dependent?, <<-PATTERN
-          (pair (sym :dependent) !(:nil))
+        def_node_matcher :dependent_option?, <<-PATTERN
+          (pair (sym :dependent) !nil)
+        PATTERN
+
+        def_node_matcher :present_option?, <<-PATTERN
+          (pair (sym :through) !nil)
+        PATTERN
+
+        def_node_matcher :with_options_block, <<-PATTERN
+          (block
+            (send nil? :with_options
+              (hash $...))
+            (args) ...)
         PATTERN
 
         def on_send(node)
-          unless is_has_many_or_has_one_without_options?(node)
-            pairs = is_has_many_or_has_one_with_options?(node)
-            return unless pairs
-            return if pairs.any? { |pair| has_dependent?(pair) }
+          if !association_without_options?(node)
+            return if valid_options?(association_with_options?(node))
+          elsif with_options_block(node.parent)
+            return if valid_options?(with_options_block(node.parent))
+          end
+
+          add_offense(node, location: :selector)
+        end
+
+        private
+
+        def valid_options?(options)
+          return true unless options
+          return true if options.any? do |o|
+            dependent_option?(o) || present_option?(o)
           end
 
-          add_offense(node, :selector)
+          false
         end
       end
     end

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

@@ -29,7 +29,7 @@ module RuboCop
         minimum_target_rails_version 5.0
 
         def_node_matcher :http_request?, <<-PATTERN
-          (send nil {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil $_data ...)
+          (send nil? {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil? $_data ...)
         PATTERN
 
         def on_send(node)
@@ -39,7 +39,8 @@ module RuboCop
           return if data.nil?
           return unless needs_conversion?(data)
 
-          add_offense(node, :selector, format(MSG, node.method_name))
+          add_offense(node, location: :selector,
+                            message: format(MSG, node.method_name))
         end
 
         # @return [Boolean] true if the line needs to be converted

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

@@ -20,19 +20,19 @@ module RuboCop
         MSG = 'Do not add a NOT NULL column without a default value.'.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
-          (send nil :add_reference _ _ (hash $...))
+          (send nil? :add_reference _ _ (hash $...))
         PATTERN
 
         def_node_matcher :null_false?, <<-PATTERN
           (pair (sym :null) (false))
         PATTERN
 
-        def_node_matcher :has_default?, <<-PATTERN
-          (pair (sym :default) !(:nil))
+        def_node_matcher :default_option?, <<-PATTERN
+          (pair (sym :default) !nil)
         PATTERN
 
         def on_send(node)
@@ -54,7 +54,7 @@ module RuboCop
 
         def check_pairs(pairs)
           return unless pairs
-          return if pairs.any? { |pair| has_default?(pair) }
+          return if pairs.any? { |pair| default_option?(pair) }
 
           null_false = pairs.find { |pair| null_false?(pair) }
           return unless null_false

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

@@ -9,13 +9,13 @@ module RuboCop
               "Use Rails's logger if you want to log.".freeze
 
         def_node_matcher :output?, <<-PATTERN
-          (send nil {:ap :p :pp :pretty_print :print :puts} ...)
+          (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
         PATTERN
 
         def on_send(node)
           return unless output?(node) && node.arguments?
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -76,8 +76,9 @@ module RuboCop
                         looks_like_rails_raw?(node) ||
                         looks_like_rails_safe_concat?(node)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
+        alias on_csend on_send
 
         private
 

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

@@ -36,15 +36,15 @@ module RuboCop
       #     something if  foo.present?
       class Present < Cop
         MSG_NOT_BLANK = 'Use `%s` instead of `%s`.'.freeze
-        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%s.present?` instead of `%s`.'.freeze
-        MSG_UNLESS_BLANK = 'Use `if %s.present?` instead of `%s`.'.freeze
+        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%s` instead of `%s`.'.freeze
+        MSG_UNLESS_BLANK = 'Use `if %s` instead of `%s`.'.freeze
 
         def_node_matcher :exists_and_not_empty?, <<-PATTERN
           (and
               {
                 (send (send $_ :nil?) :!)
                 (send (send $_ :!) :!)
-                (send $_ :!= (:nil))
+                (send $_ :!= nil)
                 $_
               }
               {
@@ -56,7 +56,7 @@ module RuboCop
         def_node_matcher :not_blank?, '(send (send $_ :blank?) :!)'
 
         def_node_matcher :unless_blank?, <<-PATTERN
-          (:if $(send $_ :blank?) {nil (...)} ...)
+          (:if $(send $_ :blank?) {nil? (...)} ...)
         PATTERN
 
         def on_send(node)
@@ -64,10 +64,9 @@ module RuboCop
 
           not_blank?(node) do |receiver|
             add_offense(node,
-                        :expression,
-                        format(MSG_NOT_BLANK,
-                               replacement(receiver),
-                               node.source))
+                        message: format(MSG_NOT_BLANK,
+                                        replacement(receiver),
+                                        node.source))
           end
         end
 
@@ -78,10 +77,9 @@ module RuboCop
             return unless variable1 == variable2
 
             add_offense(node,
-                        :expression,
-                        format(MSG_EXISTS_AND_NOT_EMPTY,
-                               variable1.source,
-                               node.source))
+                        message: format(MSG_EXISTS_AND_NOT_EMPTY,
+                                        replacement(variable1),
+                                        node.source))
           end
         end
 
@@ -91,7 +89,7 @@ module RuboCop
           exists_and_not_empty?(node) do |variable1, variable2|
             return unless variable1 == variable2
 
-            add_offense(node, :expression, MSG_EXISTS_AND_NOT_EMPTY)
+            add_offense(node, message: MSG_EXISTS_AND_NOT_EMPTY)
           end
         end
 
@@ -101,9 +99,8 @@ module RuboCop
 
           unless_blank?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)
-            add_offense(node,
-                        range,
-                        format(MSG_UNLESS_BLANK, receiver.source, range.source))
+            msg = format(MSG_UNLESS_BLANK, replacement(receiver), range.source)
+            add_offense(node, location: range, message: msg)
           end
         end
 
@@ -111,7 +108,7 @@ module RuboCop
           lambda do |corrector|
             method_call, variable1 = unless_blank?(node)
 
-            if method_call && variable1
+            if method_call
               corrector.replace(node.loc.keyword, 'if')
               range = method_call.loc.expression
             else

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

@@ -20,15 +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)
+          add_offense(node, location: :selector)
         end
 
         private

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

@@ -63,7 +63,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

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)
+            add_offense(node.source_range, location: node.source_range)
           end
         end
 

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

@@ -132,27 +132,27 @@ module RuboCop
         ].freeze
 
         def_node_matcher :irreversible_schema_statement_call, <<-PATTERN
-          (send nil ${:change_table_comment :execute :remove_belongs_to} ...)
+          (send nil? ${:change_table_comment :execute :remove_belongs_to} ...)
         PATTERN
 
         def_node_matcher :drop_table_call, <<-PATTERN
-          (send nil :drop_table ...)
+          (send nil? :drop_table ...)
         PATTERN
 
         def_node_matcher :change_column_default_call, <<-PATTERN
-          (send nil :change_column_default _ _ $...)
+          (send nil? :change_column_default _ _ $...)
         PATTERN
 
         def_node_matcher :remove_column_call, <<-PATTERN
-          (send nil :remove_column $...)
+          (send nil? :remove_column $...)
         PATTERN
 
         def_node_matcher :remove_foreign_key_call, <<-PATTERN
-          (send nil :remove_foreign_key _ $_)
+          (send nil? :remove_foreign_key _ $_)
         PATTERN
 
         def_node_matcher :change_table_call, <<-PATTERN
-          (send nil :change_table $_ ...)
+          (send nil? :change_table $_ ...)
         PATTERN
 
         def on_send(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,8 +249,8 @@ 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