endpoint.rb in grape-swagger-0.27.0

- old
+ new

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require 'active_support'
 require 'active_support/core_ext/string/inflections.rb'
 
 module Grape
   class Endpoint
@@ -33,18 +35,22 @@
       }.delete_if { |_, value| value.blank? }
     end
 
     # building info object
     def info_object(infos)
-      {
+      result = {
         title:             infos[:title] || 'API title',
         description:       infos[:description],
         termsOfServiceUrl: infos[:terms_of_service_url],
         contact:           contact_object(infos),
         license:           license_object(infos),
         version:           infos[:version]
-      }.delete_if { |_, value| value.blank? }
+      }
+
+      GrapeSwagger::DocMethods::Extensions.add_extensions_to_info(infos, result)
+
+      result.delete_if { |_, value| value.blank? }
     end
 
     # sub-objects of info object
     # license
     def license_object(infos)
@@ -106,14 +112,14 @@
       method = {}
       method[:summary]     = summary_object(route)
       method[:description] = description_object(route)
       method[:produces]    = produces_object(route, options[:produces] || options[:format])
       method[:consumes]    = consumes_object(route, options[:format])
-      method[:parameters]  = params_object(route)
+      method[:parameters]  = params_object(route, path)
       method[:security]    = security_object(route)
       method[:responses]   = response_object(route)
-      method[:tags]        = route.options.fetch(:tags, tag_object(route))
+      method[:tags]        = route.options.fetch(:tags, tag_object(route, path))
       method[:operationId] = GrapeSwagger::DocMethods::OperationId.build(route, path)
       method.delete_if { |_, value| value.blank? }
 
       [route.request_method.downcase.to_sym, method]
     end
@@ -136,13 +142,16 @@
 
       description
     end
 
     def produces_object(route, format)
+      return ['application/octet-stream'] if file_response?(route.attributes.success) &&
+                                             !route.attributes.produces.present?
+
       mime_types = GrapeSwagger::DocMethods::ProducesConsumes.call(format)
 
-      route_mime_types = [:formats, :content_types, :produces].map do |producer|
+      route_mime_types = %i(formats content_types produces).map do |producer|
         possible = route.options[producer]
         GrapeSwagger::DocMethods::ProducesConsumes.call(possible) if possible.present?
       end.flatten.compact.uniq
 
       route_mime_types.present? ? route_mime_types : mime_types
@@ -151,29 +160,29 @@
     def consumes_object(route, format)
       method = route.request_method.downcase.to_sym
       if route.settings[:description] && route.settings[:description][:consumes]
         format = route.settings[:description][:consumes]
       end
-      mime_types = GrapeSwagger::DocMethods::ProducesConsumes.call(format) if [:post, :put].include?(method)
+      mime_types = GrapeSwagger::DocMethods::ProducesConsumes.call(format) if %i(post put).include?(method)
 
       mime_types
     end
 
-    def params_object(route)
+    def params_object(route, path)
       parameters = partition_params(route).map do |param, value|
         value = { required: false }.merge(value) if value.is_a?(Hash)
         _, value = default_type([[param, value]]).first if value == ''
         if value[:type]
           expose_params(value[:type])
         elsif value[:documentation]
           expose_params(value[:documentation][:type])
         end
-        GrapeSwagger::DocMethods::ParseParams.call(param, value, route, @definitions)
+        GrapeSwagger::DocMethods::ParseParams.call(param, value, path, route, @definitions)
       end
 
       if GrapeSwagger::DocMethods::MoveParams.can_be_moved?(parameters, route.request_method)
-        parameters = GrapeSwagger::DocMethods::MoveParams.to_definition(parameters, route, @definitions)
+        parameters = GrapeSwagger::DocMethods::MoveParams.to_definition(path, parameters, route, @definitions)
       end
 
       parameters
     end
 
@@ -183,10 +192,11 @@
       codes = apply_success_codes(route) + codes
       codes.map! { |x| x.is_a?(Array) ? { code: x[0], message: x[1], model: x[2] } : x }
 
       codes.each_with_object({}) do |value, memo|
         memo[value[:code]] = { description: value[:message] }
+        next build_file_response(memo[value[:code]]) if file_response?(value[:model])
 
         response_model = @item
         response_model = expose_params_from_model(value[:model]) if value[:model]
 
         if memo.key?(200) && route.request_method == 'DELETE' && value[:model].nil?
@@ -199,11 +209,11 @@
 
         @definitions[response_model][:description] = description_object(route)
         # TODO: proof that the definition exist, if model isn't specified
         reference = { '$ref' => "#/definitions/#{response_model}" }
         memo[value[:code]][:schema] = if route.options[:is_array] && value[:code] < 300
-                                        { 'type' => 'array', 'items' => reference }
+                                        { type: 'array', items: reference }
                                       else
                                         reference
                                       end
       end
     end
@@ -221,38 +231,46 @@
       end
 
       [default_code]
     end
 
-    def tag_object(route)
+    def tag_object(route, path)
       version = GrapeSwagger::DocMethods::Version.get(route)
       version = [version] unless version.is_a?(Array)
       Array(
-        route.path.split('{')[0].split('/').reject(&:empty?).delete_if do |i|
+        path.split('{')[0].split('/').reject(&:empty?).delete_if do |i|
           i == route.prefix.to_s || version.map(&:to_s).include?(i)
         end.first
       )
     end
 
     private
 
+    def file_response?(value)
+      value.to_s.casecmp('file').zero? ? true : false
+    end
+
+    def build_file_response(memo)
+      memo['schema'] = { type: 'file' }
+    end
+
     def partition_params(route)
       declared_params = route.settings[:declared_params] if route.settings[:declared_params].present?
-      required, exposed = route.params.partition { |x| x.first.is_a? String }
+      required = merge_params(route)
       required = GrapeSwagger::DocMethods::Headers.parse(route) + required unless route.headers.nil?
 
       default_type(required)
-      default_type(exposed)
 
       request_params = unless declared_params.nil? && route.headers.nil?
                          parse_request_params(required)
                        end || {}
 
-      if route.params.present? && !route.settings[:declared_params].present?
-        request_params = route.params.merge(request_params)
-      end
+      request_params.empty? ? required : request_params
+    end
 
-      request_params
+    def merge_params(route)
+      param_keys = route.params.keys
+      route.params.delete_if { |key| key.is_a?(String) && param_keys.include?(key.to_sym) }.to_a
     end
 
     def default_type(params)
       params.each do |param|
         param[-1] = param.last == '' ? { required: true, type: 'Integer' } : param.last