Class: Mortymer::Generator

Inherits:
Dry::Swagger::DocumentationGenerator
  • Object
show all
Defined in:
lib/mortymer/generator.rb

Constant Summary collapse

SWAGGER_FIELD_TYPE_DEFINITIONS = 
{
  "string" => { type: :string },
  "integer" => { type: :integer },
  "boolean" => { type: :boolean },
  "float" => { type: :float },
  "decimal" => { type: :string, format: :decimal },
  "datetime" => { type: :string, format: :datetime },
  "date" => { type: :string, format: :date },
  "time" => { type: :string, format: :time },
  "uuid" => { type: :string, format: :uuid },
  "file" => { type: :string, format: :binary }
}.freeze

Instance Method Summary collapse

Instance Method Details

#array_of_primitive_type?(definition) ⇒ Boolean

Returns:

  • (Boolean) 


111
112
113
 
# File 'lib/mortymer/generator.rb', line 111

def array_of_primitive_type?(definition)
  definition[:array] && definition.fetch(:type) != "array"
end

#from_struct(struct) ⇒ Object 



18
19
20
 
# File 'lib/mortymer/generator.rb', line 18

def from_struct(struct)
  generate_documentation(::DryStructParser::StructSchemaParser.new.call(struct).keys)
end

#from_validation(validation) ⇒ Object 



22
23
24
 
# File 'lib/mortymer/generator.rb', line 22

def from_validation(validation)
  generate_documentation(::DryValidationParser::ValidationSchemaParser.new.call(validation).keys)
end

#generate_documentation(fields) ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/mortymer/generator.rb', line 26

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
    elsif definition[0].fetch(:required, true) && @config.enable_required_validation
      documentation[:required] << field_name
    end
  end

  { type: :object, properties: documentation[:properties], required: documentation[:required] }
end

#generate_field_properties(definition) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/mortymer/generator.rb', line 41

def generate_field_properties(definition)
  return generate_for_sti_type(definition) if definition.is_a?(Array)

  documentation = if definition[:type] == "array" || definition[:array]
                    generate_for_array(definition)
                  elsif definition[:type] == "hash"
                    generate_for_hash(definition)
                  else
                    generate_for_primitive_type(definition)
                  end
  if @config.enable_nullable_validation
    documentation.merge(@config.nullable_type => definition.fetch(:nullable, false))
  else
    documentation.merge(@config.nullable_type => true)
  end
rescue KeyError
  raise Errors::MissingTypeError
end

#generate_for_array(definition) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/mortymer/generator.rb', line 83

def generate_for_array(definition)
  items = if array_of_primitive_type?(definition)
            self.class::SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(definition.fetch(:type))
          else
            generate_documentation(definition.fetch(:keys))
          end
  items = if @config.enable_nullable_validation
            items.merge(@config.nullable_type => definition.fetch(:nullable, false))
          else
            items.merge(@config.nullable_type => true)
          end
  { type: :array, items: items }
end

#generate_for_hash(definition) ⇒ Object

Raises:

  • (Errors::MissingHashSchemaError) 


97
98
99
100
101
 
# File 'lib/mortymer/generator.rb', line 97

def generate_for_hash(definition)
  raise Errors::MissingHashSchemaError unless definition[:keys]

  generate_documentation(definition.fetch(:keys))
end

#generate_for_primitive_type(definition) ⇒ Object 



103
104
105
106
107
108
109
 
# File 'lib/mortymer/generator.rb', line 103

def generate_for_primitive_type(definition)
  documentation = self.class::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) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/mortymer/generator.rb', line 60

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