fablicop 1.10.1 → 1.10.2

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rails-2.19.1/lib/rubocop/cop/rails/has_many_or_has_one_dependent.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for `has_many` or `has_one` associations that don't
+      # specify a `:dependent` option.
+      #
+      # It doesn't register an offense if `:through` or `dependent: nil`
+      # is specified, or if the model is read-only.
+      #
+      # @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 :articles, dependent: nil
+      #     has_many :patients, through: :appointments
+      #   end
+      #
+      #   class User < ActiveRecord::Base
+      #     has_many :comments
+      #     has_one :avatar
+      #
+      #     def readonly?
+      #       true
+      #     end
+      #   end
+      class HasManyOrHasOneDependent < Base
+        MSG = 'Specify a `:dependent` option.'
+        RESTRICT_ON_SEND = %i[has_many has_one].freeze
+
+        def_node_search :active_resource_class?, <<~PATTERN
+          (const (const {nil? cbase} :ActiveResource) :Base)
+        PATTERN
+
+        def_node_matcher :association_without_options?, <<~PATTERN
+          (send _ {:has_many :has_one} _)
+        PATTERN
+
+        def_node_matcher :association_with_options?, <<~PATTERN
+          (send _ {:has_many :has_one} ... (hash $...))
+        PATTERN
+
+        def_node_matcher :dependent_option?, <<~PATTERN
+          (pair (sym :dependent) {!nil (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_node_matcher :association_extension_block?, <<~PATTERN
+          (block
+            (send nil? :has_many _)
+            (args) ...)
+        PATTERN
+
+        def_node_matcher :readonly?, <<~PATTERN
+          (def :readonly?
+            (args)
+            (true))
+        PATTERN
+
+        def on_send(node)
+          return if active_resource?(node.parent) || readonly_model?(node)
+          return if !association_without_options?(node) && valid_options?(association_with_options?(node))
+          return if valid_options_in_with_options_block?(node)
+
+          add_offense(node.loc.selector)
+        end
+
+        private
+
+        def readonly_model?(node)
+          return false unless (parent = node.parent)
+
+          parent.each_descendant(:def).any? { |def_node| readonly?(def_node) }
+        end
+
+        def valid_options_in_with_options_block?(node)
+          return true unless node.parent
+
+          n = node.parent.begin_type? || association_extension_block?(node.parent) ? node.parent.parent : node.parent
+
+          contain_valid_options_in_with_options_block?(n)
+        end
+
+        def contain_valid_options_in_with_options_block?(node)
+          if (options = with_options_block(node))
+            return true if valid_options?(options)
+
+            return false unless node.parent
+
+            return true if contain_valid_options_in_with_options_block?(node.parent.parent)
+          end
+
+          false
+        end
+
+        def valid_options?(options)
+          return false if options.nil?
+
+          options = extract_option_if_kwsplat(options)
+
+          return true unless options
+          return true if options.any? do |o|
+            dependent_option?(o) || present_option?(o)
+          end
+
+          false
+        end
+
+        def extract_option_if_kwsplat(options)
+          if options.first.kwsplat_type? && options.first.children.first.hash_type?
+            return options.first.children.first.pairs
+          end
+
+          options
+        end
+
+        def active_resource?(node)
+          return false if node.nil?
+
+          active_resource_class?(node)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rails-2.19.1/lib/rubocop/cop/rails/helper_instance_variable.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for use of the helper methods which reference
+      # instance variables.
+      #
+      # Relying on instance variables makes it difficult to re-use helper
+      # methods.
+      #
+      # If it seems awkward to explicitly pass in each dependent
+      # variable, consider moving the behavior elsewhere, for
+      # example to a model, decorator or presenter.
+      #
+      # Provided that a class inherits `ActionView::Helpers::FormBuilder`,
+      # an offense will not be registered.
+      #
+      # @example
+      #   # bad
+      #   def welcome_message
+      #     "Hello #{@user.name}"
+      #   end
+      #
+      #   # good
+      #   def welcome_message(user)
+      #     "Hello #{user.name}"
+      #   end
+      #
+      #   # good
+      #   class MyFormBuilder < ActionView::Helpers::FormBuilder
+      #     @template.do_something
+      #   end
+      class HelperInstanceVariable < Base
+        MSG = 'Do not use instance variables in helpers.'
+
+        def_node_matcher :form_builder_class?, <<~PATTERN
+          (const
+            (const
+               (const {nil? cbase} :ActionView) :Helpers) :FormBuilder)
+        PATTERN
+
+        def on_ivar(node)
+          return if inherit_form_builder?(node)
+
+          add_offense(node)
+        end
+
+        def on_ivasgn(node)
+          return if node.parent.or_asgn_type? || inherit_form_builder?(node)
+
+          add_offense(node.loc.name)
+        end
+
+        private
+
+        def inherit_form_builder?(node)
+          node.each_ancestor(:class) do |class_node|
+            return true if form_builder_class?(class_node.parent_class)
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rails-2.19.1/lib/rubocop/cop/rails/http_positional_arguments.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies 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 running Rails < 5 you should disable the
+      # Rails/HttpPositionalArguments cop or set your TargetRailsVersion in your
+      # .rubocop.yml file to 4.2.
+      #
+      # NOTE: It does not detect any cases where `include Rack::Test::Methods` is used
+      # which makes the http methods incompatible behavior.
+      #
+      # @example
+      #   # bad
+      #   get :new, { user_id: 1}
+      #
+      #   # good
+      #   get :new, params: { user_id: 1 }
+      #   get :new, **options
+      class HttpPositionalArguments < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use keyword arguments instead of positional arguments for http call: `%<verb>s`.'
+        KEYWORD_ARGS = %i[method params session body flash xhr as headers env to].freeze
+        ROUTING_METHODS = %i[draw routes].freeze
+        RESTRICT_ON_SEND = %i[get post put patch delete head].freeze
+
+        minimum_target_rails_version 5.0
+
+        def_node_matcher :http_request?, <<~PATTERN
+          (send nil? {#{RESTRICT_ON_SEND.map(&:inspect).join(' ')}} !nil? $_ ...)
+        PATTERN
+
+        def_node_matcher :kwsplat_hash?, <<~PATTERN
+          (hash (kwsplat _))
+        PATTERN
+
+        def_node_matcher :include_rack_test_methods?, <<~PATTERN
+          (send nil? :include
+            (const
+              (const
+                (const {nil? cbase} :Rack) :Test) :Methods))
+        PATTERN
+
+        def on_send(node)
+          return if in_routing_block?(node) || use_rack_test_methods?
+
+          http_request?(node) do |data|
+            return unless needs_conversion?(data)
+
+            message = format(MSG, verb: node.method_name)
+
+            add_offense(highlight_range(node), message: message) do |corrector|
+              # given a pre Rails 5 method: get :new, {user_id: @user.id}, {}
+              #
+              # @return lambda of auto correct procedure
+              # the result should look like:
+              #     get :new, params: { user_id: @user.id }, session: {}
+              # 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
+              # the Rails 5 http call
+              corrector.replace(node, correction(node))
+            end
+          end
+        end
+
+        private
+
+        def in_routing_block?(node)
+          !!node.each_ancestor(:block).detect { |block| ROUTING_METHODS.include?(block.method_name) }
+        end
+
+        def use_rack_test_methods?
+          processed_source.ast.each_descendant(:send).any? do |node|
+            include_rack_test_methods?(node)
+          end
+        end
+
+        def needs_conversion?(data)
+          return true unless data.hash_type?
+          return false if kwsplat_hash?(data)
+
+          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 highlight_range(node)
+          _http_path, *data = *node.arguments
+
+          range_between(data.first.source_range.begin_pos, data.last.source_range.end_pos)
+        end
+
+        def convert_hash_data(data, type)
+          return '' if data.hash_type? && data.empty?
+
+          hash_data = if data.hash_type?
+                        format('{ %<data>s }', data: data.pairs.map(&:source).join(', '))
+                      else
+                        # user supplies an object,
+                        # no need to surround with braces
+                        data.source
+                      end
+
+          format(', %<type>s: %<hash_data>s', type: type, hash_data: hash_data)
+        end
+
+        def correction(node)
+          http_path, *data = *node.arguments
+
+          controller_action = http_path.source
+          params = convert_hash_data(data.first, 'params')
+          session = convert_hash_data(data.last, 'session') if data.size > 1
+
+          format(correction_template(node), name: node.method_name,
+                                            action: controller_action,
+                                            params: params,
+                                            session: session)
+        end
+
+        def correction_template(node)
+          if parentheses?(node)
+            '%<name>s(%<action>s%<params>s%<session>s)'
+          else
+            '%<name>s %<action>s%<params>s%<session>s'
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rails-2.19.1/lib/rubocop/cop/rails/http_status.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces use of symbolic or numeric value to define HTTP status.
+      #
+      # @example EnforcedStyle: symbolic (default)
+      #   # bad
+      #   render :foo, status: 200
+      #   render json: { foo: 'bar' }, status: 200
+      #   render plain: 'foo/bar', status: 304
+      #   redirect_to root_url, status: 301
+      #   head 200
+      #
+      #   # good
+      #   render :foo, status: :ok
+      #   render json: { foo: 'bar' }, status: :ok
+      #   render plain: 'foo/bar', status: :not_modified
+      #   redirect_to root_url, status: :moved_permanently
+      #   head :ok
+      #
+      # @example EnforcedStyle: numeric
+      #   # bad
+      #   render :foo, status: :ok
+      #   render json: { foo: 'bar' }, status: :not_found
+      #   render plain: 'foo/bar', status: :not_modified
+      #   redirect_to root_url, status: :moved_permanently
+      #   head :ok
+      #
+      #   # good
+      #   render :foo, status: 200
+      #   render json: { foo: 'bar' }, status: 404
+      #   render plain: 'foo/bar', status: 304
+      #   redirect_to root_url, status: 301
+      #   head 200
+      #
+      class HttpStatus < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[render redirect_to head].freeze
+
+        def_node_matcher :http_status, <<~PATTERN
+          {
+            (send nil? {:render :redirect_to} _ $hash)
+            (send nil? {:render :redirect_to} $hash)
+            (send nil? :head ${int sym} ...)
+          }
+        PATTERN
+
+        def_node_matcher :status_code, <<~PATTERN
+          (hash <(pair (sym :status) ${int sym}) ...>)
+        PATTERN
+
+        def on_send(node)
+          http_status(node) do |hash_node_or_status_code|
+            status = if hash_node_or_status_code.hash_type?
+                       status_code(hash_node_or_status_code)
+                     else
+                       hash_node_or_status_code
+                     end
+            return unless status
+
+            checker = checker_class.new(status)
+            return unless checker.offensive?
+
+            add_offense(checker.node, message: checker.message) do |corrector|
+              corrector.replace(checker.node, checker.preferred_style)
+            end
+          end
+        end
+
+        private
+
+        def checker_class
+          case style
+          when :symbolic
+            SymbolicStyleChecker
+          when :numeric
+            NumericStyleChecker
+          end
+        end
+
+        # :nodoc:
+        class SymbolicStyleChecker
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` to define HTTP status code.'
+
+          attr_reader :node
+
+          def initialize(node)
+            @node = node
+          end
+
+          def offensive?
+            !node.sym_type? && !custom_http_status_code?
+          end
+
+          def message
+            format(MSG, prefer: preferred_style, current: number.to_s)
+          end
+
+          def preferred_style
+            symbol.inspect
+          end
+
+          private
+
+          def symbol
+            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
+          end
+
+          def number
+            node.children.first
+          end
+
+          def custom_http_status_code?
+            node.int_type? && !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
+          end
+        end
+
+        # :nodoc:
+        class NumericStyleChecker
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` to define HTTP status code.'
+          PERMITTED_STATUS = %i[error success missing redirect].freeze
+
+          attr_reader :node
+
+          def initialize(node)
+            @node = node
+          end
+
+          def offensive?
+            !node.int_type? && !permitted_symbol?
+          end
+
+          def message
+            format(MSG, prefer: preferred_style, current: symbol.inspect)
+          end
+
+          def preferred_style
+            number.to_s
+          end
+
+          private
+
+          def number
+            ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol]
+          end
+
+          def symbol
+            node.value
+          end
+
+          def permitted_symbol?
+            node.sym_type? && PERMITTED_STATUS.include?(node.value)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rails-2.19.1/lib/rubocop/cop/rails/i18n_lazy_lookup.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for places where I18n "lazy" lookup can be used.
+      #
+      # @example
+      #   # en.yml
+      #   # en:
+      #   #   books:
+      #   #     create:
+      #   #       success: Book created!
+      #
+      #   # bad
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('books.create.success')
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('.success')
+      #     end
+      #   end
+      #
+      class I18nLazyLookup < Base
+        include VisibilityHelp
+        extend AutoCorrector
+
+        MSG = 'Use "lazy" lookup for the text used in controllers.'
+
+        RESTRICT_ON_SEND = %i[translate t].freeze
+
+        def_node_matcher :translate_call?, <<~PATTERN
+          (send nil? {:translate :t} ${sym_type? str_type?} ...)
+        PATTERN
+
+        def on_send(node)
+          translate_call?(node) do |key_node|
+            key = key_node.value
+            return if key.to_s.start_with?('.')
+
+            controller, action = controller_and_action(node)
+            return unless controller && action
+
+            scoped_key = get_scoped_key(key_node, controller, action)
+            return unless key == scoped_key
+
+            add_offense(key_node) do |corrector|
+              unscoped_key = key_node.value.to_s.split('.').last
+              corrector.replace(key_node, "'.#{unscoped_key}'")
+            end
+          end
+        end
+
+        private
+
+        def controller_and_action(node)
+          action_node = node.each_ancestor(:def).first
+          return unless action_node && node_visibility(action_node) == :public
+
+          controller_node = node.each_ancestor(:class).first
+          return unless controller_node && controller_node.identifier.source.end_with?('Controller')
+
+          [controller_node, action_node]
+        end
+
+        def get_scoped_key(key_node, controller, action)
+          path = controller_path(controller).tr('/', '.')
+          action_name = action.method_name
+          key = key_node.value.to_s.split('.').last
+
+          "#{path}.#{action_name}.#{key}"
+        end
+
+        def controller_path(controller)
+          module_name = controller.parent_module_name
+          controller_name = controller.identifier.source
+
+          path = if module_name == 'Object'
+                   controller_name
+                 else
+                   "#{module_name}::#{controller_name}"
+                 end
+
+          path.delete_suffix('Controller').underscore
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-rails-2.19.1/lib/rubocop/cop/rails/i18n_locale_assignment.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for the use of `I18n.locale=` method.
+      #
+      # The `locale` attribute persists for the rest of the Ruby runtime, potentially causing
+      # unexpected behavior at a later time.
+      # Using `I18n.with_locale` ensures the code passed in the block is the only place `I18n.locale` is affected.
+      # It eliminates the possibility of a `locale` sticking around longer than intended.
+      #
+      # @example
+      #   # bad
+      #   I18n.locale = :fr
+      #
+      #   # good
+      #   I18n.with_locale(:fr) do
+      #   end
+      #
+      class I18nLocaleAssignment < Base
+        MSG = 'Use `I18n.with_locale` with block instead of `I18n.locale=`.'
+        RESTRICT_ON_SEND = %i[locale=].freeze
+
+        def_node_matcher :i18n_locale_assignment?, <<~PATTERN
+          (send (const {nil? cbase} :I18n) :locale= ...)
+        PATTERN
+
+        def on_send(node)
+          return unless i18n_locale_assignment?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end