rubocop 0.49.1 → 0.50.0

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

@@ -29,7 +29,7 @@ module RuboCop
 
           return unless offending_node
 
-          add_offense(offending_node, :expression)
+          add_offense(offending_node)
         end
 
         private

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

@@ -22,9 +22,9 @@ module RuboCop
 
         MSG = 'Duplicate value `%s` found in `%s` enum declaration.'.freeze
 
-        def_node_matcher :enum_declaration, <<-END
+        def_node_matcher :enum_declaration, <<-PATTERN
           (send nil :enum (hash (pair (_ $_) ${array hash})))
-        END
+        PATTERN
 
         def on_send(node)
           enum_declaration(node) do |name, args|

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

@@ -43,7 +43,7 @@ module RuboCop
 
         def check_for_file_join_with_rails_root(node)
           return unless file_join_nodes?(node)
-          return unless node.method_args.any? { |e| rails_root_nodes?(e) }
+          return unless node.arguments.any? { |e| rails_root_nodes?(e) }
 
           register_offense(node)
         end
@@ -51,7 +51,7 @@ module RuboCop
         def check_for_rails_root_join_with_slash_separated_path(node)
           return unless rails_root_nodes?(node)
           return unless rails_root_join_nodes?(node)
-          return unless node.method_args.any? { |arg| string_with_slash?(arg) }
+          return unless node.arguments.any? { |arg| string_with_slash?(arg) }
 
           register_offense(node)
         end
@@ -65,8 +65,7 @@ module RuboCop
 
           add_offense(
             node,
-            source_range(processed_source.buffer, node.loc.line, line_range),
-            MSG
+            source_range(processed_source.buffer, node.loc.line, line_range)
           )
         end
       end

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, node.loc.selector, MSG)
+          add_offense(node, :selector)
         end
 
         def autocorrect(node)

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for `has_many` or `has_one` associations that don't
+      # specify a `:dependent` option.
+      #
+      # @example
+      #   # bad
+      #   class User < ActiveRecord::Base
+      #     has_many :comments
+      #     has_one :avatar
+      #   end
+      #
+      #   # good
+      #   class User < ActiveRecord::Base
+      #     has_many :comments, dependent: :restrict_with_exception
+      #     has_one :avatar, dependent: :destroy
+      #   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} _)
+        PATTERN
+
+        def_node_matcher :is_has_many_or_has_one_with_options?, <<-PATTERN
+          (send nil {:has_many :has_one} _ (hash $...))
+        PATTERN
+
+        def_node_matcher :has_dependent?, <<-PATTERN
+          (pair (sym :dependent) !(:nil))
+        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) }
+          end
+
+          add_offense(node, :selector)
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module RuboCop
       # This cop is used to identify usages of http methods like `get`, `post`,
       # `put`, `patch` without the usage of keyword arguments in your tests and
       # change them to use keyword args.  This cop only applies to Rails >= 5 .
-      # If you are not running Rails < 5 you should disable # the
+      # If you are running Rails < 5 you should disable the
       # Rails/HttpPositionalArguments cop or set your TargetRailsVersion in your
       # .rubocop.yml file to 4.0, etc.
       #
@@ -28,9 +28,9 @@ module RuboCop
 
         minimum_target_rails_version 5.0
 
-        def_node_matcher :http_request?, <<-END
+        def_node_matcher :http_request?, <<-PATTERN
           (send nil {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil $_data ...)
-        END
+        PATTERN
 
         def on_send(node)
           data = http_request?(node)
@@ -39,7 +39,7 @@ module RuboCop
           return if data.nil?
           return unless needs_conversion?(data)
 
-          add_offense(node, node.loc.selector, format(MSG, node.method_name))
+          add_offense(node, :selector, format(MSG, node.method_name))
         end
 
         # @return [Boolean] true if the line needs to be converted
@@ -81,7 +81,7 @@ module RuboCop
         # @return lambda of auto correct procedure
         # the result should look like:
         #     get :new, params: { user_id: @user.id }, headers: {}
-        # the http_method is the method use to call the controller
+        # the http_method is the method used to call the controller
         # the controller node can be a symbol, method, object or string
         # that represents the path/action on the Rails controller
         # the data is the http parameters and environment sent in

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

@@ -59,7 +59,7 @@ module RuboCop
           null_false = pairs.find { |pair| null_false?(pair) }
           return unless null_false
 
-          add_offense(null_false, :expression)
+          add_offense(null_false)
         end
       end
     end

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

@@ -34,7 +34,7 @@ module RuboCop
 
           return unless offense?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         private
@@ -77,7 +77,7 @@ module RuboCop
         end
 
         def singular_receiver?(number)
-          number == 1
+          number.abs == 1
         end
 
         def plural_receiver?(number)

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

@@ -71,7 +71,7 @@ module RuboCop
         def relative_date_method?(node)
           node.send_type? &&
             RELATIVE_DATE_METHODS.include?(node.method_name) &&
-            node.method_args.empty?
+            !node.arguments?
         end
 
         def autocorrect(node)

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

@@ -33,7 +33,7 @@ module RuboCop
           referer?(node) do
             return unless node.method?(wrong_method_name)
 
-            add_offense(node.source_range, node.source_range, message)
+            add_offense(node.source_range, 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
+        def_node_matcher :irreversible_schema_statement_call, <<-PATTERN
           (send nil ${:change_table_comment :execute :remove_belongs_to} ...)
-        END
+        PATTERN
 
-        def_node_matcher :drop_table_call, <<-END
+        def_node_matcher :drop_table_call, <<-PATTERN
           (send nil :drop_table ...)
-        END
+        PATTERN
 
-        def_node_matcher :change_column_default_call, <<-END
+        def_node_matcher :change_column_default_call, <<-PATTERN
           (send nil :change_column_default _ _ $...)
-        END
+        PATTERN
 
-        def_node_matcher :remove_column_call, <<-END
+        def_node_matcher :remove_column_call, <<-PATTERN
           (send nil :remove_column $...)
-        END
+        PATTERN
 
-        def_node_matcher :remove_foreign_key_call, <<-END
+        def_node_matcher :remove_foreign_key_call, <<-PATTERN
           (send nil :remove_foreign_key _ $_)
-        END
+        PATTERN
 
-        def_node_matcher :change_table_call, <<-END
+        def_node_matcher :change_table_call, <<-PATTERN
           (send nil :change_table $_ ...)
-        END
+        PATTERN
 
         def on_send(node)
           return unless within_change_method?(node)

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

@@ -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,7 +70,7 @@ module RuboCop
           return unless expected_signature?(node)
           return if persisted_referenced?(assignment)
 
-          add_offense(node, node.loc.selector,
+          add_offense(node, :selector,
                       format(CREATE_MSG,
                              "#{node.method_name}!",
                              node.method_name.to_s,
@@ -84,7 +84,7 @@ module RuboCop
           return if check_used_in_conditional(node)
           return if last_call_of_method?(node)
 
-          add_offense(node, node.loc.selector,
+          add_offense(node, :selector,
                       format(MSG,
                              "#{node.method_name}!",
                              node.method_name.to_s))
@@ -121,7 +121,7 @@ module RuboCop
           return false unless conditional?(node)
 
           unless MODIFY_PERSIST_METHODS.include?(node.method_name)
-            add_offense(node, node.loc.selector,
+            add_offense(node, :selector,
                         format(CREATE_CONDITIONAL_MSG,
                                node.method_name.to_s))
           end
@@ -130,8 +130,10 @@ module RuboCop
         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)

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

@@ -20,7 +20,7 @@ module RuboCop
 
         def on_send(node)
           scope?(node) do |second_arg|
-            add_offense(second_arg, :expression)
+            add_offense(second_arg)
           end
         end
       end

data/lib/rubocop/cop/security/eval.rb

@@ -14,9 +14,9 @@ module RuboCop
       class Eval < Cop
         MSG = 'The use of `eval` is a serious security risk.'.freeze
 
-        def_node_matcher :eval?, <<-END
+        def_node_matcher :eval?, <<-PATTERN
           (send {nil (send nil :binding)} :eval $!str ...)
-        END
+        PATTERN
 
         def on_send(node)
           eval?(node) do |code|

data/lib/rubocop/cop/security/json_load.rb

@@ -25,9 +25,9 @@ module RuboCop
       class JSONLoad < Cop
         MSG = 'Prefer `JSON.parse` over `JSON.%s`.'.freeze
 
-        def_node_matcher :json_load, <<-END
+        def_node_matcher :json_load, <<-PATTERN
           (send (const {nil cbase} :JSON) ${:load :restore} ...)
-        END
+        PATTERN
 
         def on_send(node)
           json_load(node) do |method|

data/lib/rubocop/cop/security/marshal_load.rb

@@ -21,10 +21,10 @@ module RuboCop
       class MarshalLoad < Cop
         MSG = 'Avoid using `Marshal.%s`.'.freeze
 
-        def_node_matcher :marshal_load, <<-END
+        def_node_matcher :marshal_load, <<-PATTERN
           (send (const {nil cbase} :Marshal) ${:load :restore}
           !(send (const {nil cbase} :Marshal) :dump ...))
-        END
+        PATTERN
 
         def on_send(node)
           marshal_load(node) do |method|

data/lib/rubocop/cop/security/yaml_load.rb

@@ -18,9 +18,9 @@ module RuboCop
       class YAMLLoad < Cop
         MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'.freeze
 
-        def_node_matcher :yaml_load, <<-END
+        def_node_matcher :yaml_load, <<-PATTERN
           (send (const {nil cbase} :YAML) :load ...)
-        END
+        PATTERN
 
         def on_send(node)
           yaml_load(node) do

data/lib/rubocop/cop/style/alias.rb

@@ -3,10 +3,30 @@
 module RuboCop
   module Cop
     module Style
-      # This cop finds uses of `alias` where `alias_method` would be more
-      # appropriate (or is simply preferred due to configuration), and vice
-      # versa.
-      # It also finds uses of `alias :symbol` rather than `alias bareword`.
+      # This cop enforces the use of either `#alias` or `#alias_method`
+      # depending on configuration.
+      # It also flags uses of `alias :symbol` rather than `alias bareword`.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: prefer_alias
+      #
+      #   # good
+      #   alias bar foo
+      #
+      #   # bad
+      #   alias_method :bar, :foo
+      #   alias :bar :foo
+      #
+      # @example
+      #
+      #   # EnforcedStyle: prefer_alias_method
+      #
+      #   # good
+      #   alias_method :bar, :foo
+      #
+      #   # bad
+      #   alias bar foo
       class Alias < Cop
         include ConfigurableEnforcedStyle
 
@@ -16,34 +36,31 @@ module RuboCop
 
         def on_send(node)
           return unless node.command?(:alias_method)
-          return if style == :prefer_alias_method
-          return if scope_type(node) == :dynamic
+          return unless style == :prefer_alias && alias_keyword_possible?(node)
 
           msg = format(MSG_ALIAS_METHOD, lexical_scope_type(node))
           add_offense(node, :selector, msg)
         end
 
         def on_alias(node)
-          # alias_method can't be used with global variables
-          return if node.each_child_node(:gvar).any?
-          # alias_method can't be used in instance_eval blocks
-          scope_type = scope_type(node)
-          return if scope_type == :instance_eval
+          return unless alias_method_possible?(node)
 
-          if scope_type == :dynamic || style == :prefer_alias_method
+          if scope_type(node) == :dynamic || style == :prefer_alias_method
             add_offense(node, :keyword, MSG_ALIAS)
           elsif node.children.none? { |arg| bareword?(arg) }
             add_offense_for_args(node)
           end
         end
 
-        def add_offense_for_args(node)
-          existing_args  = node.children.map(&:source).join(' ')
-          preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
-          arg_ranges     = node.children.map(&:source_range)
-          msg            = format(MSG_SYMBOL_ARGS, preferred_args,
-                                  existing_args)
-          add_offense(node, arg_ranges.reduce(&:join), msg)
+        private
+
+        def alias_keyword_possible?(node)
+          scope_type(node) != :dynamic && node.arguments.all?(&:sym_type?)
+        end
+
+        def alias_method_possible?(node)
+          scope_type(node) != :instance_eval &&
+            node.children.none?(&:gvar_type?)
         end
 
         def autocorrect(node)
@@ -56,7 +73,14 @@ module RuboCop
           end
         end
 
-        private
+        def add_offense_for_args(node)
+          existing_args  = node.children.map(&:source).join(' ')
+          preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
+          arg_ranges     = node.children.map(&:source_range)
+          msg            = format(MSG_SYMBOL_ARGS, preferred_args,
+                                  existing_args)
+          add_offense(node, arg_ranges.reduce(&:join), msg)
+        end
 
         # In this expression, will `self` be the same as the innermost enclosing
         # class or module block (:lexical)? Or will it be something else