Class Endpoint has 40 methods (exceeds 20 allowed). Consider refactoring.

Open

  class Endpoint # rubocop:disable Metrics/ClassLength
    def content_types_for(target_class)
      content_types = (target_class.content_types || {}).values

      if content_types.empty?

File endpoint.rb has 368 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require 'active_support'
require 'active_support/core_ext/string/inflections'
require 'grape-swagger/endpoint/params_parser'

module Grape

Method response_object has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.

Open

    def response_object(route, options)
      codes(route).each_with_object({}) do |value, memo|
        value[:message] ||= ''
        memo[value[:code]] = { description: value[:message] ||= '' } unless memo[value[:code]].present?
        memo[value[:code]][:headers] = value[:headers] if value[:headers]

• Read up
  Read up

Class MoveParams has 25 methods (exceeds 20 allowed). Consider refactoring.

Open

    class MoveParams
      class << self
        attr_accessor :definitions

        def can_be_moved?(http_verb, params)

Method success_code_from_entity has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

    def success_code_from_entity(route, entity)
      default_code = GrapeSwagger::DocMethods::StatusCodes.get[route.request_method.downcase.to_sym]
      if entity.is_a?(Hash)
        default_code[:code] = entity[:code] if entity[:code].present?
        default_code[:model] = entity[:model] if entity[:model].present?

• Read up
  Read up

Method combine_routes has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

  def combine_routes(app, doc_klass)
    app.routes.each_with_object({}) do |route, combined_routes|
      route_path = route.path
      route_match = route_path.split(/^.*?#{route.prefix}/).last
      next unless route_match

• Read up
  Read up

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

Open

        def param_type(value_type, consumes)
          param_type = value_type[:param_type] || value_type[:in]
          if !value_type[:is_array] && value_type[:path].include?("{#{value_type[:param_name]}}")
            'path'
          elsif param_type

• Read up
  Read up

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

Open

    def params_object(route, options, path, consumes)
      parameters = build_request_params(route, options).each_with_object([]) do |(param, value), memo|
        next if hidden_parameter?(value)

        value = { required: false }.merge(value) if value.is_a?(Hash)

• Read up
  Read up

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

Open

        def move_params_to_new(definition, params)
          params, nested_params = params.partition { |x| !x[:name].to_s.include?('[') }
          params.each do |param|
            property = param[:name]

• Read up
  Read up

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

Open

        def parse_array_item(definitions, type, value_type)
          array_items = {}
          if definitions[value_type[:data_type]]
            array_items['$ref'] = "#/definitions/#{@parsed_param[:type]}"
          else

• Read up
  Read up

Method setup has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def setup(options)
      options = DEFAULTS.merge(options)

      # options could be set on #add_swagger_documentation call,
      # for available options see #defaults

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

Open

        def document_length_limits(value_type)
          if value_type[:is_array]
            @parsed_param[:minItems] = value_type[:min_length] if value_type.key?(:min_length)
            @parsed_param[:maxItems] = value_type[:max_length] if value_type.key?(:max_length)
          else

• Read up
  Read up

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

Open

        def build(route, options = {})
          path = route.path.dup
          # always removing format
          path.sub!(/\(\.\w+?\)$/, '')
          path.sub!('(.:format)', '')

• Read up
  Read up

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

Open

    def build_memo_schema(memo, route, value, response_model, options)
      if memo[value[:code]][:schema] && value[:as]
        memo[value[:code]][:schema][:properties].merge!(build_reference(route, value, response_model, options))

        if value[:required]

• Read up
  Read up

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

Open

        def parse_additional_properties(definitions, settings)
          return false unless settings.key?(:additionalProperties) || settings.key?(:additional_properties)

          value =
            if settings.key?(:additionalProperties)

• Read up
  Read up

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

Open

        def parse_enum_or_range_values(values)
          case values
          when Proc
            parse_enum_or_range_values(values.call) if values.parameters.empty?
          when Range

• Read up
  Read up

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

Open

      def parse_request_params
        public_params.each_with_object({}) do |(name, options), memo|
          name = name.to_s
          param_type = options[:type]
          param_type = param_type.to_s unless param_type.nil?

• Read up
  Read up

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

Open

    def build_reference(route, value, response_model, settings)
      # TODO: proof that the definition exist, if model isn't specified
      reference = if value.key?(:as)
                    { value[:as] => build_reference_hash(response_model) }
                  else

• Read up
  Read up

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

Open

  def combine_namespaces(app)
    combined_namespaces = {}
    endpoints = app.endpoints.clone

    while endpoints.any?

• Read up
  Read up

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

Open

        def call(param, settings, path, route, definitions, consumes) # rubocop:disable Metrics/ParameterLists
          method = route.request_method
          additional_documentation = settings.fetch(:documentation, {})
          settings.merge!(additional_documentation)
          data_type = DataType.call(settings)

• Read up
  Read up