rubocop 0.71.0 → 0.72.0

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

@@ -1,94 +0,0 @@
-# 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

@@ -1,246 +0,0 @@
-# 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

@@ -1,175 +0,0 @@
-# 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