Class ParamsScope has 35 methods (exceeds 20 allowed). Consider refactoring.

Open

    class ParamsScope
      attr_accessor :element, :parent, :index
      attr_reader :type

      include Grape::DSL::Parameters

File params_scope.rb has 322 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require_relative 'attributes_doc'

module Grape
  module Validations
    class ParamsScope

Method infer_coercion has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

      def infer_coercion(validations)
        raise ArgumentError, ':type may not be supplied with :types' if validations.key?(:type) && validations.key?(:types)

        validations[:coerce] = (options_key?(:type, :value, validations) ? validations[:type][:value] : validations[:type]) if validations.key?(:type)
        validations[:coerce_message] = (options_key?(:type, :message, validations) ? validations[:type][:message] : nil) if validations.key?(:type)

• Read up
  Read up

Method validate_value_coercion has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

      def validate_value_coercion(coerce_type, *values_list)
        return unless coerce_type

        coerce_type = coerce_type.first if coerce_type.is_a?(Array)
        values_list.each do |values|

• Read up
  Read up

Method new_scope has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def new_scope(attrs, optional = false, &block)
        # if required params are grouped and no type or unsupported type is provided, raise an error
        type = attrs[1] ? attrs[1][:type] : nil
        if attrs.first && !optional
          raise Grape::Exceptions::MissingGroupType if type.nil?

• Read up
  Read up

Method meets_hash_dependency? has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def meets_hash_dependency?(params)
        # params might be anything what looks like a hash, so it must implement a `key?` method
        return false unless params.respond_to?(:key?)

        @dependent_on.each do |dependency|

• Read up
  Read up

Method check_incompatible_option_values has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

      def check_incompatible_option_values(default, values, except_values, excepts)
        return unless default && !default.is_a?(Proc)

        raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values) if values && !values.is_a?(Proc) && !Array(default).all? { |def_val| values.include?(def_val) }

• Read up
  Read up

Method guess_coerce_type has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def guess_coerce_type(coerce_type, *values_list)
        return coerce_type unless coerce_type == Array

        values_list.each do |values|
          next if !values || values.is_a?(Proc)

• Read up
  Read up

Method validate has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

      def validate(type, options, attrs, doc, opts)

Method push_declared_params has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def push_declared_params(attrs, **opts)
        opts = opts.merge(declared_params_scope: self) unless opts.key?(:declared_params_scope)
        if lateral?
          @parent.push_declared_params(attrs, **opts)
        else

• Read up
  Read up

Method validates has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def validates(attrs, validations)
        doc = AttributesDoc.new @api, self
        doc.extract_details validations

        coerce_type = infer_coercion(validations)

• Read up
  Read up

Method require_required_and_optional_fields has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def require_required_and_optional_fields(context, opts)
        if context == :all
          optional_fields = Array(opts[:except])
          required_fields = opts[:using].keys - optional_fields
        else # context == :none

• Read up
  Read up

Method extract_message_option has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def extract_message_option(attrs)
        return nil unless attrs.is_a?(Array)

        opts = attrs.last.is_a?(Hash) ? attrs.pop : {}
        opts.key?(:message) && !opts[:message].nil? ? opts.delete(:message) : nil

• Read up
  Read up

Method meets_dependency? has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

      def meets_dependency?(params, request_params)
        return true unless @dependent_on

        return false if @parent.present? && !@parent.meets_dependency?(@parent.params(request_params), request_params)

• Read up
  Read up

Method should_validate? has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

      def should_validate?(parameters)
        scoped_params = params(parameters)

        return false if @optional && (scoped_params.blank? || all_element_blank?(scoped_params))
        return false unless meets_dependency?(scoped_params, parameters)

• Read up
  Read up