rubocop 0.51.0 → 0.52.0

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

@@ -32,14 +32,14 @@ module RuboCop
           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/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
 

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

@@ -4,6 +4,13 @@ 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
 

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

@@ -49,8 +49,12 @@ module RuboCop
         def on_send(node)
           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))
+          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)

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

@@ -29,52 +29,16 @@ 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? $_ ...)
         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, location: :selector,
-                            message: 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, {}
@@ -101,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

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that methods specified in the filter's `only`
+      # or `except` options are explicitly defined in the controller.
+      #
+      # You can specify methods of superclass or methods added by mixins
+      # on the filter, but these confuse developers. If you specify methods
+      # where are defined on another controller, you should define the filter
+      # in that controller.
+      #
+      # @example
+      #   # bad
+      #   class LoginController < ApplicationController
+      #     before_action :require_login, only: %i[index settings logout]
+      #
+      #     def index
+      #     end
+      #   end
+      #
+      #   # good
+      #   class LoginController < ApplicationController
+      #     before_action :require_login, only: %i[index settings logout]
+      #
+      #     def index
+      #     end
+      #
+      #     def settings
+      #     end
+      #
+      #     def logout
+      #     end
+      #   end
+      class LexicallyScopedActionFilter < Cop
+        MSG = '%s not explicitly defined on the controller.'.freeze
+
+        FILTERS = %w[
+          :after_action
+          :append_after_action
+          :append_around_action
+          :append_before_action
+          :around_action
+          :before_action
+          :prepend_after_action
+          :prepend_around_action
+          :prepend_before_action
+          :skip_after_action
+          :skip_around_action
+          :skip_before_action
+          :skip_action_callback
+        ].freeze
+
+        def_node_matcher :only_or_except_filter_methods, <<-PATTERN
+          (send
+            nil?
+            {#{FILTERS.join(' ')}}
+            _
+            (hash
+              (pair
+                (sym {:only :except})
+                $_)))
+        PATTERN
+
+        def on_send(node)
+          methods_node = only_or_except_filter_methods(node)
+          return unless methods_node
+
+          defined_methods = node.parent.each_child_node(:def).map(&:method_name)
+          methods = array_values(methods_node).reject do |method|
+            defined_methods.include?(method)
+          end
+
+          add_offense(node, message: message(methods)) unless methods.empty?
+        end
+
+        private
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Array<Symbol>]
+        def array_values(node) # rubocop:disable Metrics/MethodLength
+          case node.type
+          when :str
+            [node.str_content.to_sym]
+          when :sym
+            [node.value]
+          when :array
+            node.values.map do |v|
+              case v.type
+              when :str
+                v.str_content.to_sym
+              when :sym
+                v.value
+              end
+            end.compact
+          else
+            []
+          end
+        end
+
+        def message(methods)
+          if methods.size == 1
+            format(MSG, "`#{methods[0]}` is")
+          else
+            format(MSG, "`#{methods.join('`, `')}` are")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,15 @@ module RuboCop
   module Cop
     module Rails
       # This cop checks for the use of output calls like puts and print
+      #
+      # @example
+      #   # bad
+      #   puts 'A debug message'
+      #   pp 'A debug message'
+      #   print 'A debug message'
+      #
+      #   # good
+      #   Rails.logger.debug 'A debug message'
       class Output < Cop
         MSG = 'Do not write to stdout. ' \
               "Use Rails's logger if you want to log.".freeze