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 321 lines of code (exceeds 250 allowed). Consider refactoring.

Open

module Grape
  module Validations
    class ParamsScope
      attr_accessor :element, :parent, :index
      attr_reader :type

Class Instance has 26 methods (exceeds 20 allowed). Consider refactoring.

Open

    class Instance
      include Grape::DSL::API

      class << self
        attr_reader :instance, :base

Method add_head_not_allowed_methods_and_options_methods has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.

Open

      def add_head_not_allowed_methods_and_options_methods
        versioned_route_configs = collect_route_config_per_pattern
        # The paths we collected are prepared (cf. Path#prepare), so they
        # contain already versioning information when using path versioning.
        # Disable versioning so adding a route won't prepend versioning

• Read up
  Read up

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 mount has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

        def mount(mounts, *opts)
          mounts = { mounts => '/' } unless mounts.respond_to?(:each_pair)
          mounts.each_pair do |app, path|
            if app.respond_to?(:mount_instance)
              opts_with = opts.any? ? opts.first[:with] : {}

• Read up
  Read up

Method validate! has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

        def validate!(params)
          attributes = SingleAttributeIterator.new(self, @scope, params)
          # we collect errors inside array because
          # there may be more than one error per field
          array_errors = []

• Read up
  Read up

File inside_route.rb has 266 lines of code (exceeds 250 allowed). Consider refactoring.

Open

module Grape
  module DSL
    module InsideRoute
      extend ActiveSupport::Concern
      include Grape::DSL::Settings

Class Router has 22 methods (exceeds 20 allowed). Consider refactoring.

Open

  class Router
    attr_reader :map, :compiled

    def self.normalize_path(path)
      path = +"/#{path}"

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 read_rack_input has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

      def read_rack_input(body)
        fmt = request.media_type ? mime_types[request.media_type] : options[:default_format]

        throw :error, status: 415, message: "The provided content-type '#{request.media_type}' is not supported." unless content_type_for(fmt)
        parser = Grape::Parser.parser_for fmt, **options

• Read up
  Read up

Method present has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

      def present(*args)
        options = args.count > 1 ? args.extract_options! : {}
        key, object = if args.count == 2 && args.first.is_a?(Symbol)
                        args
                      else

• Read up
  Read up

Consider simplifying this complex logical expression.

Open

        return unless
          (request.post? || request.put? || request.patch? || request.delete?) &&
          (!request.form_data? || !request.media_type) &&
          !request.parseable_data? &&
          (request.content_length.to_i.positive? || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED)

Method optional has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

      def optional(*attrs, &block)
        orig_attrs = attrs.clone

        opts = attrs.extract_options!.clone
        type = opts[:type]

• Read up
  Read up

Method present has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

      def present(message, env)
        present_options = {}
        presented_message = message
        if presented_message.is_a?(Hash)
          presented_message = presented_message.dup

• Read up
  Read up

Method status has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

      def status(status = nil)
        case status
        when Symbol
          raise ArgumentError, "Status code :#{status} is invalid." unless Rack::Utils::SYMBOL_TO_STATUS_CODE.key?(status)

• Read up
  Read up

Method validate_param! has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

        def validate_param!(attr_name, params)
          return unless params.is_a?(Hash)

          val = params[attr_name]

• Read up
  Read up

Method mount has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def mount(mounts, *opts)
          mounts = { mounts => '/' } unless mounts.respond_to?(:each_pair)
          mounts.each_pair do |app, path|
            if app.respond_to?(:mount_instance)
              opts_with = opts.any? ? opts.first[:with] : {}

Method do_each has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

      def do_each(params_to_process, parent_indicies = [], &block)
        params_to_process.each_with_index do |resource_params, index|
          # when we get arrays of arrays it means that target element located inside array
          # we need this because we want to know parent arrays indicies
          if resource_params.is_a?(Array)

• Read up
  Read up

Method desc has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

      def desc(description, options = {}, &config_block)
        if config_block
          endpoint_configuration = if defined?(configuration)
                                     # When the instance is mounted - the configuration is executed on mount time
                                     if configuration.respond_to?(:evaluate)

• Read up
  Read up