rubocop 0.49.1 → 0.52.0

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
@@ -29,17 +29,17 @@ module RuboCop
 
           return unless offending_node
 
-          add_offense(offending_node, :expression)
+          add_offense(offending_node)
         end
 
-        private
-
         def autocorrect(pair_node)
           lambda do |corrector|
             corrector.replace(pair_node.key.source_range, 'allow_nil')
           end
         end
 
+        private
+
         def allow_blank_option(node)
           delegate_options(node) do |hash|
             hash.pairs.find { |opt| allow_blank_option?(opt) }

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

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that Rails.env is compared using `.production?`-like
+      # methods instead of equality against a string or symbol.
+      #
+      # @example
+      #   # bad
+      #   Rails.env == 'production'
+      #
+      #   # bad, always returns false
+      #   Rails.env == :test
+      #
+      #   # good
+      #   Rails.env.production?
+      class EnvironmentComparison < Cop
+        MSG = 'Favor `Rails.env.%s?` over `Rails.env == %s`.'.freeze
+
+        SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always ' \
+          'evaluate to `false`.'.freeze
+
+        def_node_matcher :environment_str_comparison?, <<-PATTERN
+          (send
+            (send (const {nil? cbase} :Rails) :env)
+            :==
+            $str
+          )
+        PATTERN
+
+        def_node_matcher :environment_sym_comparison?, <<-PATTERN
+          (send
+            (send (const {nil? cbase} :Rails) :env)
+            :==
+            $sym
+          )
+        PATTERN
+
+        def on_send(node)
+          environment_str_comparison?(node) do |env_node|
+            env, = *env_node
+            add_offense(node, message: format(MSG, env, env_node.source))
+          end
+          environment_sym_comparison?(node) do |_|
+            add_offense(node, message: SYM_MSG)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, replacement(node))
+          end
+        end
+
+        private
+
+        def replacement(node)
+          receiver, _, compared = *node
+          environment, = *compared
+          "#{receiver.source}.#{environment}?"
+        end
+      end
+    end
+  end
+end

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

@@ -16,6 +16,13 @@ module RuboCop
       # - Usage in application code outside of the web process could result in
       # the program exiting, which could result in the code failing to run and
       # do its job.
+      #
+      # @example
+      #   # bad
+      #   exit(0)
+      #
+      #   # good
+      #   raise 'a bad error has happened'
       class Exit < Cop
         include ConfigurableEnforcedStyle
 
@@ -24,7 +31,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)
@@ -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
@@ -62,12 +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),
-            MSG
-          )
+          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, node.loc.selector, MSG)
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)

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

@@ -4,13 +4,20 @@ module RuboCop
   module Cop
     module Rails
       # This cop checks for the use of the has_and_belongs_to_many macro.
+      #
+      # @example
+      #   # bad
+      #   # has_and_belongs_to_many :ingredients
+      #
+      #   # good
+      #   # has_many :ingredients, through: :recipe_ingredients
       class HasAndBelongsToMany < Cop
         MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'.freeze
 
         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

@@ -0,0 +1,76 @@
+# 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.
+      # It doesn't register an offense if `:through` option was specified.
+      #
+      # @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
+      #     has_many :patients, through: :appointments
+      #   end
+      class HasManyOrHasOneDependent < Cop
+        MSG = 'Specify a `:dependent` option.'.freeze
+
+        def_node_matcher :association_without_options?, <<-PATTERN
+          (send nil? {:has_many :has_one} _)
+        PATTERN
+
+        def_node_matcher :association_with_options?, <<-PATTERN
+          (send nil? {:has_many :has_one} _ (hash $...))
+        PATTERN
+
+        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)
+          if !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
+
+          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
+
+          false
+        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,52 +28,17 @@ module RuboCop
 
         minimum_target_rails_version 5.0
 
-        def_node_matcher :http_request?, <<-END
-          (send nil {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil $_data ...)
-        END
+        def_node_matcher :http_request?, <<-PATTERN
+          (send nil? {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil? $_ ...)
+        PATTERN
 
         def on_send(node)
-          data = http_request?(node)
-          # if the data is nil then we don't need to add keyword arguments
-          # because there is no data to put in params or headers, so skip
-          return if data.nil?
-          return unless needs_conversion?(data)
+          http_request?(node) do |data|
+            return unless needs_conversion?(data)
 
-          add_offense(node, node.loc.selector, format(MSG, node.method_name))
-        end
-
-        # @return [Boolean] true if the line needs to be converted
-        def needs_conversion?(data)
-          return true unless data.hash_type?
-          children = data.child_nodes
-
-          value = children.find do |d|
-            special_keyword_arg?(d.children.first) ||
-              (format_arg?(d.children.first) && children.size == 1)
+            add_offense(node, location: :selector,
+                              message: format(MSG, node.method_name))
           end
-
-          value.nil?
-        end
-
-        def special_keyword_arg?(node)
-          KEYWORD_ARGS.include?(node.children.first) if node.sym_type?
-        end
-
-        def format_arg?(node)
-          node.children.first == :format if node.sym_type?
-        end
-
-        def convert_hash_data(data, type)
-          # empty hash or no hash return empty string
-          return '' if data.nil? || data.children.empty?
-          hash_data = if data.hash_type?
-                        format('{ %s }', data.pairs.map(&:source).join(', '))
-                      else
-                        # user supplies an object,
-                        # no need to surround with braces
-                        data.source
-                      end
-          format(', %s: %s', type, hash_data)
         end
 
         # given a pre Rails 5 method: get :new, user_id: @user.id, {}
@@ -81,7 +46,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
@@ -100,6 +65,37 @@ module RuboCop
                             params, headers)
           ->(corrector) { corrector.replace(code_to_replace, new_code) }
         end
+
+        def needs_conversion?(data)
+          return true unless data.hash_type?
+
+          data.each_pair.none? do |pair|
+            special_keyword_arg?(pair.key) ||
+              format_arg?(pair.key) && data.pairs.one?
+          end
+        end
+
+        def special_keyword_arg?(node)
+          node.sym_type? && KEYWORD_ARGS.include?(node.value)
+        end
+
+        def format_arg?(node)
+          node.sym_type? && node.value == :format
+        end
+
+        def convert_hash_data(data, type)
+          return '' if data.hash_type? && data.empty?
+
+          hash_data = if data.hash_type?
+                        format('{ %s }', data.pairs.map(&:source).join(', '))
+                      else
+                        # user supplies an object,
+                        # no need to surround with braces
+                        data.source
+                      end
+
+          format(', %s: %s', type, hash_data)
+        end
       end
     end
   end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for has_(one|many) and belongs_to associations where
+      # ActiveRecord can't automatically determine the inverse association
+      # because of a scope or the options used. This can result in unnecessary
+      # queries in some circumstances. `:inverse_of` must be manually specified
+      # for associations to work in both ways, or set to `false` to opt-out.
+      #
+      # @example
+      #   # bad
+      #   class Blog < ApplicationRecord
+      #     has_many :recent_posts, -> { order(published_at: :desc) }
+      #   end
+      #
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     has_many(:recent_posts,
+      #       -> { order(published_at: :desc) },
+      #       inverse_of: :blog
+      #     )
+      #   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
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 4.1
+
+        MSG = 'Specify an `:inverse_of` option.'.freeze
+
+        def_node_matcher :association_arguments, <<-PATTERN
+          (send nil? {:has_many :has_one :belongs_to} _ $...)
+        PATTERN
+
+        def_node_matcher :options_from_argument, <<-PATTERN
+          (hash $...)
+        PATTERN
+
+        def_node_matcher :conditions_option?, <<-PATTERN
+          (pair (sym :conditions) !nil)
+        PATTERN
+
+        def_node_matcher :through_option?, <<-PATTERN
+          (pair (sym :through) !nil)
+        PATTERN
+
+        def_node_matcher :polymorphic_option?, <<-PATTERN
+          (pair (sym :polymorphic) !nil)
+        PATTERN
+
+        def_node_matcher :foreign_key_option?, <<-PATTERN
+          (pair (sym :foreign_key) !nil)
+        PATTERN
+
+        def_node_matcher :inverse_of_option?, <<-PATTERN
+          (pair (sym :inverse_of) !nil)
+        PATTERN
+
+        def on_send(node)
+          arguments = association_arguments(node)
+          return unless arguments
+
+          options = arguments.flat_map { |arg| options_from_argument(arg) }
+          return unless scope?(arguments) ||
+                        options_requiring_inverse_of?(options)
+
+          return if options_contain_inverse_of?(options)
+          add_offense(node, location: :selector)
+        end
+
+        def scope?(arguments)
+          arguments.any?(&:block_type?)
+        end
+
+        def options_requiring_inverse_of?(options)
+          required = options.any? do |opt|
+            conditions_option?(opt) ||
+              through_option?(opt) ||
+              foreign_key_option?(opt)
+          end
+
+          return required if target_rails_version >= 5.2
+          required || options.any? { |opt| polymorphic_option?(opt) }
+        end
+
+        def options_contain_inverse_of?(options)
+          options.any? { |opt| inverse_of_option?(opt) }
+        end
+      end
+    end
+  end
+end