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

Open

      def read_body_input
        return unless
          (request.post? || request.put? || request.patch? || request.delete?) &&
          (!request.form_data? || !request.media_type) &&
          !request.parseable_data? &&

• Read up
  Read up

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

Open

    def rotation(env, exact_route = nil)
      response = nil
      input, method = *extract_input_and_method(env)
      map[method].each do |route|
        next if exact_route == route

• Read up
  Read up

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

Open

        def declared_hash_attr(passed_params, options, declared_param, params_nested_path, memo)
          renamed_params = route_setting(:renamed_params) || {}
          if declared_param.is_a?(Hash)
            declared_param.each_pair do |declared_parent_param, declared_children_params|
              params_nested_path_dup = params_nested_path.dup

• 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

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

Open

        def rescue_from(*args, &block)
          if args.last.is_a?(Proc)
            handler = args.pop
          elsif block
            handler = block

• Read up
  Read up

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

Open

        def namespace(space = nil, options = {}, &block)
          @namespace_description = nil unless instance_variable_defined?(:@namespace_description) && @namespace_description

          if space || block
            within_namespace do

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

Open

      def entity_class_for_obj(object, options)
        entity_class = options.delete(:with)

        if entity_class.nil?
          # entity class not explicitly defined, auto-detect from relation#klass or first object in the collection

• Read up
  Read up

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

Open

      def map_params(params, element, is_array = false)
        if params.is_a?(Array)
          params.map do |el|
            map_params(el, element, true)
          end

• Read up
  Read up

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

Open

        def handle_passed_param(params_nested_path, has_passed_children = false, &_block)
          return yield if has_passed_children

          key = params_nested_path[0]
          key += "[#{params_nested_path[1..].join('][')}]" if params_nested_path.size > 1

• Read up
  Read up

Method rescue_from has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def rescue_from(*args, &block)
          if args.last.is_a?(Proc)
            handler = args.pop
          elsif block
            handler = block

Method declared_hash_attr has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def declared_hash_attr(passed_params, options, declared_param, params_nested_path, memo)
          renamed_params = route_setting(:renamed_params) || {}
          if declared_param.is_a?(Hash)
            declared_param.each_pair do |declared_parent_param, declared_children_params|
              params_nested_path_dup = params_nested_path.dup

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

Open

        def enforce_symbolized_keys(type, method)
          # Collections have all values processed individually
          if [Array, Set].include?(type)
            lambda do |val|
              method.call(val).tap do |new_val|

• Read up
  Read up

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

Open

        def version(*args, &block)
          if args.any?
            options = args.extract_options!
            options = options.reverse_merge(using: :path)
            requested_versions = args.flatten

• 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 validate_param! has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

        def validate_param!(attr_name, params)
          return unless params.respond_to?(:key?) && params.key?(attr_name)
          return if Array.wrap(params[attr_name]).all? { |param| param.nil? || param.to_s.match?((options_key?(:value) ? @option[:value] : @option)) }

          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))

• Read up
  Read up

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

Open

        def validate_param!(attr_name, params)
          return unless params.respond_to?(:key?) && params.key?(attr_name)

          excepts = @except.is_a?(Proc) ? @except.call : @except
          return if excepts.nil?

• Read up
  Read up

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

Open

        def initialize(type, strict = false)
          super

          @type = type

• Read up
  Read up