class Dry::Swagger::DocumentationGenerator

Constants

SWAGGER_FIELD_TYPE_DEFINITIONS

Public Class Methods

new(config) click to toggle source
# File lib/dry/swagger/documentation_generator.rb, line 14
def initialize(config)
  @config = config
end

Public Instance Methods

array_of_primitive_type?(definition) click to toggle source
# File lib/dry/swagger/documentation_generator.rb, line 101
def array_of_primitive_type?(definition)
  definition[:array] && definition.fetch(:type) != 'array'
end
generate_documentation(fields) click to toggle source
# File lib/dry/swagger/documentation_generator.rb, line 18
def generate_documentation(fields)
  documentation = { properties: {}, required: [] }
  fields.each do |field_name, definition|
    documentation[:properties][field_name] = generate_field_properties(definition)
    if definition.is_a?(Hash)
      documentation[:required] << field_name if definition.fetch(:required, true) && @config.enable_required_validation
    else
      documentation[:required] << field_name if definition[0].fetch(:required, true) && @config.enable_required_validation
    end

  rescue Errors::MissingTypeError => e
    raise StandardError.new e.message % { field_name: field_name, valid_types: SWAGGER_FIELD_TYPE_DEFINITIONS.keys, definition: definition }
  rescue Errors::MissingHashSchemaError => e
    raise StandardError.new e.message % { field_name: field_name, valid_types: SWAGGER_FIELD_TYPE_DEFINITIONS.keys, definition: definition }
  end

  { :type => :object, :properties => documentation[:properties], :required => documentation[:required] }
end
generate_field_properties(definition) click to toggle source
# File lib/dry/swagger/documentation_generator.rb, line 37
def generate_field_properties(definition)
  return generate_for_sti_type(definition) if definition.is_a?(Array)

  if definition[:type] == 'array' || definition[:array]
    documentation = generate_for_array(definition)
  elsif definition[:type] == 'hash'
    documentation = generate_for_hash(definition)
  else
    documentation = generate_for_primitive_type(definition)
  end
  @config.enable_nullable_validation ?
      documentation.merge(@config.nullable_type => definition.fetch(@config.nullable_type, false)) :
      documentation.merge(@config.nullable_type => true)

rescue KeyError
  raise Errors::MissingTypeError.new
end
generate_for_array(definition) click to toggle source
# File lib/dry/swagger/documentation_generator.rb, line 78
def generate_for_array(definition)
  items = array_of_primitive_type?(definition) ?
              SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(definition.fetch(:type)) :
              generate_documentation(definition.fetch(:keys))
  items =  @config.enable_nullable_validation ?
               items.merge(@config.nullable_type => definition.fetch(@config.nullable_type, false)) :
               items.merge(@config.nullable_type => true)
  { type: :array, items: items }
end
generate_for_hash(definition) click to toggle source
# File lib/dry/swagger/documentation_generator.rb, line 88
def generate_for_hash(definition)
  raise Errors::MissingHashSchemaError.new unless definition[:keys]
  generate_documentation(definition.fetch(:keys))
end
generate_for_primitive_type(definition) click to toggle source
# File lib/dry/swagger/documentation_generator.rb, line 93
def generate_for_primitive_type(definition)
  documentation = SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(definition.fetch(:type))
  documentation = documentation.merge(enum: definition.fetch(:enum)) if definition[:enum] && @config.enable_enums
  documentation = documentation.merge(description: definition.fetch(:description)) if definition[:description] &&
                                                                                      @config.enable_descriptions
  documentation
end
generate_for_sti_type(definition) click to toggle source
# File lib/dry/swagger/documentation_generator.rb, line 55
def generate_for_sti_type(definition)
  properties = {}

  definition.each_with_index do |_, index|
    properties["definition_#{index + 1}"] = generate_field_properties(definition[index])
  end

  documentation = {
      type: :object,
      properties: properties,
      example: 'Dynamic Field. See Model Definitions'
  }

  if definition[0][:type] == 'array'
    definition.each { |it| it[:type] = 'hash'}
    documentation[:oneOf] = definition.map{ |it| generate_field_properties(it) }
    { type: :array, items: documentation }
  else
    documentation[:oneOf] = definition.map{ |it| generate_field_properties(it) }
    documentation
  end
end