lib/dry/swagger/documentation_generator.rb in dry-swagger-0.5.2 vs lib/dry/swagger/documentation_generator.rb in dry-swagger-0.6.0

@@ -15,85 +15,92 @@
         @config = config
       end
 
       def generate_documentation(fields)
         documentation = { properties: {}, required: [] }
-        fields.each do |field_name, attributes_hash|
-          documentation[:properties][field_name] = generate_field_properties(attributes_hash)
-          if attributes_hash.is_a?(Hash)
-            documentation[:required] << field_name if attributes_hash.fetch(:required, true) && @config.enable_required_validation
+        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 attributes_hash[0].fetch(:required, true) && @config.enable_required_validation
+            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, attributes_hash: attributes_hash }
+          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, attributes_hash: attributes_hash }
+          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
 
-      def generate_field_properties(attributes_hash)
-        if attributes_hash.is_a?(Array)
-          properties = {}
-          attributes_hash.each_with_index do |_, index|
-            properties["definition_#{index + 1}"] = generate_field_properties(attributes_hash[index])
-          end
-          if attributes_hash[0][:type] == 'array'
-            attributes_hash.each { |definition| definition[:type] = 'hash'}
-            {
-                type: :array,
-                items: {
-                    type: :object,
-                    properties: properties,
-                    oneOf: attributes_hash.map{ |it| generate_field_properties(it) },
-                    example: 'Dynamic Field. See Model Definitions'
-                },
-            }
-          else
-            {
-                oneOf: attributes_hash.map{ |it| generate_field_properties(it) },
-                type: :object,
-                properties: properties,
-                example: 'Dynamic Field. See Model Definitions'
-            }
-          end
-        else
-          if attributes_hash[:type] == 'array'
-            items = generate_documentation(attributes_hash.fetch(:keys))
-            items =  @config.enable_nullable_validation ?
-                         items.merge(@config.nullable_type => attributes_hash.fetch(@config.nullable_type, false)) :
-                         items.merge(@config.nullable_type => true)
-            documentation = { type: :array, items: items }
-          elsif attributes_hash[:array] && attributes_hash.fetch(:type) != 'array'
-            items = SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(attributes_hash.fetch(:type))
-            items = @config.enable_nullable_validation ?
-                        items.merge(@config.nullable_type => attributes_hash.fetch(@config.nullable_type, false)) :
-                        items.merge(@config.nullable_type => true)
-            documentation = { type: :array, items:  items }
-          elsif attributes_hash[:type] == 'hash'
-            raise Errors::MissingHashSchemaError.new unless attributes_hash[:keys]
-            documentation = generate_documentation(attributes_hash.fetch(:keys))
-          else
-            documentation = SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(attributes_hash.fetch(:type))
-            if attributes_hash[:enum] && @config.enable_enums
-              documentation = documentation.merge(enum: attributes_hash.fetch(:enum))
-            end
+      def generate_field_properties(definition)
+        return generate_for_sti_type(definition) if definition.is_a?(Array)
 
-            if attributes_hash[:description] && @config.enable_descriptions
-              documentation = documentation.merge(description: attributes_hash.fetch(:description))
-            end
-          end
-
-          @config.enable_nullable_validation ?
-              documentation.merge(@config.nullable_type => attributes_hash.fetch(@config.nullable_type, false)) :
-              documentation.merge(@config.nullable_type => true)
+        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
+
+      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
+
+      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
+
+      def generate_for_hash(definition)
+        raise Errors::MissingHashSchemaError.new unless definition[:keys]
+        generate_documentation(definition.fetch(:keys))
+      end
+
+      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
+
+      def array_of_primitive_type?(definition)
+        definition[:array] && definition.fetch(:type) != 'array'
       end
     end
   end
 end