rubocop-rails 2.4.1

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that `if` and `only` (or `except`) are not used together
+      # as options of `skip_*` action filter.
+      #
+      # The `if` option will be ignored when `if` and `only` are used together.
+      # Similarly, the `except` option will be ignored when `if` and `except`
+      # are used together.
+      #
+      # @example
+      #   # bad
+      #   class MyPageController < ApplicationController
+      #     skip_before_action :login_required,
+      #       only: :show, if: :trusted_origin?
+      #   end
+      #
+      #   # good
+      #   class MyPageController < ApplicationController
+      #     skip_before_action :login_required,
+      #       if: -> { trusted_origin? && action_name == "show" }
+      #   end
+      #
+      # @example
+      #   # bad
+      #   class MyPageController < ApplicationController
+      #     skip_before_action :login_required,
+      #       except: :admin, if: :trusted_origin?
+      #   end
+      #
+      #   # good
+      #   class MyPageController < ApplicationController
+      #     skip_before_action :login_required,
+      #       if: -> { trusted_origin? && action_name != "admin" }
+      #   end
+      #
+      # @see https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-_normalize_callback_options
+      class IgnoredSkipActionFilterOption < Cop
+        MSG = <<~MSG.chomp.freeze
+          `%<ignore>s` option will be ignored when `%<prefer>s` and `%<ignore>s` are used together.
+        MSG
+
+        FILTERS = %w[
+          :skip_after_action
+          :skip_around_action
+          :skip_before_action
+          :skip_action_callback
+        ].freeze
+
+        def_node_matcher :filter_options, <<~PATTERN
+          (send
+            nil?
+            {#{FILTERS.join(' ')}}
+            _
+            $_)
+        PATTERN
+
+        def on_send(node)
+          options = filter_options(node)
+          return unless options
+          return unless options.hash_type?
+
+          options = options_hash(options)
+
+          if if_and_only?(options)
+            add_offense(options[:if],
+                        message: format(MSG, prefer: :only, ignore: :if))
+          elsif if_and_except?(options)
+            add_offense(options[:except],
+                        message: format(MSG, prefer: :if, ignore: :except))
+          end
+        end
+
+        private
+
+        def options_hash(options)
+          options.pairs
+                 .select { |pair| pair.key.sym_type? }
+                 .map { |pair| [pair.key.value, pair] }.to_h
+        end
+
+        def if_and_only?(options)
+          options.key?(:if) && options.key?(:only)
+        end
+
+        def if_and_except?(options)
+          options.key?(:if) && options.key?(:except)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for has_(one|many) and belongs_to associations where
+      # Active Record can't automatically determine the inverse association
+      # because of a scope or the options used. Using the blog with order scope
+      # example below, traversing the a Blog's association in both directions
+      # with `blog.posts.first.blog` would cause the `blog` to be loaded from
+      # the database twice.
+      #
+      # `:inverse_of` must be manually specified for Active Record to use the
+      # associated object in memory, or set to `false` to opt-out. Note that
+      # setting `nil` does not stop Active Record from trying to determine the
+      # inverse automatically, and is not considered a valid value for this.
+      #
+      # @example
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     has_many :posts
+      #   end
+      #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
+      #   end
+      #
+      # @example
+      #   # bad
+      #   class Blog < ApplicationRecord
+      #     has_many :posts, -> { order(published_at: :desc) }
+      #   end
+      #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
+      #   end
+      #
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     has_many(:posts,
+      #              -> { order(published_at: :desc) },
+      #              inverse_of: :blog)
+      #   end
+      #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
+      #   end
+      #
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     with_options inverse_of: :blog do
+      #       has_many :posts, -> { order(published_at: :desc) }
+      #     end
+      #   end
+      #
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog
+      #   end
+      #
+      #   # good
+      #   # When you don't want to use the inverse association.
+      #   class Blog < ApplicationRecord
+      #     has_many(:posts,
+      #              -> { order(published_at: :desc) },
+      #              inverse_of: false)
+      #   end
+      #
+      # @example
+      #   # bad
+      #   class Picture < ApplicationRecord
+      #     belongs_to :imageable, polymorphic: true
+      #   end
+      #
+      #   class Employee < ApplicationRecord
+      #     has_many :pictures, as: :imageable
+      #   end
+      #
+      #   class Product < ApplicationRecord
+      #     has_many :pictures, as: :imageable
+      #   end
+      #
+      #   # good
+      #   class Picture < ApplicationRecord
+      #     belongs_to :imageable, polymorphic: true
+      #   end
+      #
+      #   class Employee < ApplicationRecord
+      #     has_many :pictures, as: :imageable, inverse_of: :imageable
+      #   end
+      #
+      #   class Product < ApplicationRecord
+      #     has_many :pictures, as: :imageable, inverse_of: :imageable
+      #   end
+      #
+      # @example
+      #   # bad
+      #   # However, RuboCop can not detect this pattern...
+      #   class Physician < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :patients, through: :appointments
+      #   end
+      #
+      #   class Appointment < ApplicationRecord
+      #     belongs_to :physician
+      #     belongs_to :patient
+      #   end
+      #
+      #   class Patient < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :physicians, through: :appointments
+      #   end
+      #
+      #   # good
+      #   class Physician < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :patients, through: :appointments
+      #   end
+      #
+      #   class Appointment < ApplicationRecord
+      #     belongs_to :physician, inverse_of: :appointments
+      #     belongs_to :patient, inverse_of: :appointments
+      #   end
+      #
+      #   class Patient < ApplicationRecord
+      #     has_many :appointments
+      #     has_many :physicians, through: :appointments
+      #   end
+      #
+      # @see https://guides.rubyonrails.org/association_basics.html#bi-directional-associations
+      # @see https://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
+
+        SPECIFY_MSG = 'Specify an `:inverse_of` option.'
+        NIL_MSG = 'You specified `inverse_of: nil`, you probably meant to ' \
+          'use `inverse_of: false`.'
+
+        def_node_matcher :association_recv_arguments, <<~PATTERN
+          (send $_ {: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 :as_option?, <<~PATTERN
+          (pair (sym :as) !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_node_matcher :inverse_of_nil_option?, <<~PATTERN
+          (pair (sym :inverse_of) nil)
+        PATTERN
+
+        def on_send(node)
+          recv, arguments = association_recv_arguments(node)
+          return unless arguments
+
+          with_options = with_options_arguments(recv, node)
+
+          options = arguments.concat(with_options).flat_map do |arg|
+            options_from_argument(arg)
+          end
+          return if options_ignoring_inverse_of?(options)
+
+          return unless scope?(arguments) ||
+                        options_requiring_inverse_of?(options)
+
+          return if options_contain_inverse_of?(options)
+
+          add_offense(node, message: message(options), 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) ||
+              foreign_key_option?(opt)
+          end
+
+          return required if target_rails_version >= 5.2
+
+          required || options.any? { |opt| as_option?(opt) }
+        end
+
+        def options_ignoring_inverse_of?(options)
+          options.any? do |opt|
+            through_option?(opt) || polymorphic_option?(opt)
+          end
+        end
+
+        def options_contain_inverse_of?(options)
+          options.any? { |opt| inverse_of_option?(opt) }
+        end
+
+        def with_options_arguments(recv, node)
+          blocks = node.each_ancestor(:block).select do |block|
+            block.send_node.command?(:with_options) &&
+              same_context_in_with_options?(block.arguments.first, recv)
+          end
+          blocks.flat_map { |n| n.send_node.arguments }
+        end
+
+        def same_context_in_with_options?(arg, recv)
+          return true if arg.nil? && recv.nil?
+
+          arg && recv && arg.children[0] == recv.children[0]
+        end
+
+        private
+
+        def message(options)
+          if options.any? { |opt| inverse_of_nil_option?(opt) }
+            NIL_MSG
+          else
+            SPECIFY_MSG
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+# 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 defined within the same class or module.
+      #
+      # You can technically specify methods of superclass or methods added by
+      # mixins on the filter, but these can confuse developers. If you specify
+      # methods that are defined in other classes or modules, you should
+      # define the filter in that class or module.
+      #
+      # If you rely on behaviour defined in the superclass actions, you must
+      # remember to invoke `super` in the subclass actions.
+      #
+      # @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
+      #
+      # @example
+      #   # bad
+      #   module FooMixin
+      #     extend ActiveSupport::Concern
+      #
+      #     included do
+      #       before_action proc { authenticate }, only: :foo
+      #     end
+      #   end
+      #
+      #   # good
+      #   module FooMixin
+      #     extend ActiveSupport::Concern
+      #
+      #     included do
+      #       before_action proc { authenticate }, only: :foo
+      #     end
+      #
+      #     def foo
+      #       # something
+      #     end
+      #   end
+      #
+      # @example
+      #   class ContentController < ApplicationController
+      #     def update
+      #       @content.update(content_attributes)
+      #     end
+      #   end
+      #
+      #   class ArticlesController < ContentController
+      #     before_action :load_article, only: [:update]
+      #
+      #     # the cop requires this method, but it relies on behaviour defined
+      #     # in the superclass, so needs to invoke `super`
+      #     def update
+      #       super
+      #     end
+      #
+      #     private
+      #
+      #     def load_article
+      #       @content = Article.find(params[:article_id])
+      #     end
+      #   end
+      class LexicallyScopedActionFilter < Cop
+        MSG = '%<action>s not explicitly defined on the %<type>s.'
+
+        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
+
+          parent = node.each_ancestor(:class, :module).first
+          return unless parent
+
+          block = parent.each_child_node(:begin).first
+          return unless block
+
+          defined_methods = block.each_child_node(:def).map(&:method_name)
+          methods = array_values(methods_node).reject do |method|
+            defined_methods.include?(method)
+          end
+
+          message = message(methods, parent)
+          add_offense(node, message: message) 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
+
+        # @param methods [Array<String>]
+        # @param parent [RuboCop::AST::Node]
+        # @return [String]
+        def message(methods, parent)
+          if methods.size == 1
+            format(MSG,
+                   action: "`#{methods[0]}` is",
+                   type: parent.type)
+          else
+            format(MSG,
+                   action: "`#{methods.join('`, `')}` are",
+                   type: parent.type)
+          end
+        end
+      end
+    end
+  end
+end