lib/grape-swagger/endpoint.rb in grape-swagger-0.24.0 vs lib/grape-swagger/endpoint.rb in grape-swagger-0.25.0

@@ -1,7 +1,5 @@
-# frozen_string_literal: true
-
 require 'active_support'
 require 'active_support/core_ext/string/inflections.rb'
 
 module Grape
   class Endpoint
@@ -27,11 +25,10 @@
         produces:       content_types_for(target_class),
         authorizations: options[:authorizations],
         securityDefinitions: options[:security_definitions],
         host:           GrapeSwagger::DocMethods::OptionalObject.build(:host, options, request),
         basePath:       GrapeSwagger::DocMethods::OptionalObject.build(:base_path, options, request),
-        tags:           GrapeSwagger::DocMethods::TagNameDescription.build(options),
         schemes:        options[:schemes].is_a?(String) ? [options[:schemes]] : options[:schemes]
       }.delete_if { |_, value| value.blank? }
     end
 
     # building info object
@@ -110,11 +107,11 @@
       method[:produces]    = produces_object(route, options[:produces] || options[:format])
       method[:consumes]    = consumes_object(route, options[:format])
       method[:parameters]  = params_object(route)
       method[:security]    = security_object(route)
       method[:responses]   = response_object(route, options[:markdown])
-      method[:tags]        = tag_object(route)
+      method[:tags]        = route.options.fetch(:tags, tag_object(route))
       method[:operationId] = GrapeSwagger::DocMethods::OperationId.build(route, path)
       method.delete_if { |_, value| value.blank? }
 
       [route.request_method.downcase.to_sym, method]
     end
@@ -162,11 +159,16 @@
 
     def params_object(route)
       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 == ''
-        GrapeSwagger::DocMethods::ParseParams.call(param, value, route)
+        if value[:type]
+          expose_params(value[:type])
+        elsif value[:documentation]
+          expose_params(value[:documentation][:type])
+        end
+        GrapeSwagger::DocMethods::ParseParams.call(param, value, route, @definitions)
       end
 
       if GrapeSwagger::DocMethods::MoveParams.can_be_moved?(parameters, route.request_method)
         parameters = GrapeSwagger::DocMethods::MoveParams.to_definition(parameters, route, @definitions)
       end
@@ -260,52 +262,47 @@
       return false unless param_types
       param_types = param_types[0].split(',') if param_types
       param_types.size == 1
     end
 
+    def expose_params(value)
+      if value.is_a?(Class) && GrapeSwagger.model_parsers.find(value)
+        expose_params_from_model(value)
+      elsif value.is_a?(String)
+        begin
+          expose_params(Object.const_get(value.gsub(/\[|\]/, ''))) # try to load class from its name
+        rescue NameError
+          nil
+        end
+      end
+    end
+
     def expose_params_from_model(model)
+      model = model.is_a?(String) ? model.constantize : model
       model_name = model_name(model)
 
       return model_name if @definitions.key?(model_name)
       @definitions[model_name] = nil
 
-      properties = nil
-      parser = nil
-
-      GrapeSwagger.model_parsers.each do |klass, ancestor|
-        next unless model.ancestors.map(&:to_s).include?(ancestor)
-        parser = klass.new(model, self)
-        break
-      end
-
-      properties = parser.call unless parser.nil?
-
+      parser = GrapeSwagger.model_parsers.find(model)
       raise GrapeSwagger::Errors::UnregisteredParser, "No parser registered for #{model_name}." unless parser
+
+      properties = parser.new(model, self).call
       raise GrapeSwagger::Errors::SwaggerSpec, "Empty model #{model_name}, swagger 2.0 doesn't support empty definitions." unless properties && properties.any?
 
-      @definitions[model_name] = { type: 'object', properties: properties }
+      @definitions[model_name] = GrapeSwagger::DocMethods::BuildModelDefinition.build(model, properties)
 
       model_name
     end
 
     def model_name(name)
-      if name.respond_to?(:entity_name)
-        name.entity_name
-      elsif name.to_s.end_with?('Entity', 'Entities')
-        length = 0
-        name.to_s.split('::')[0..-2].reverse.take_while do |x|
-          length += x.length
-          length < 42
-        end.reverse.join
-      else
-        name.name.demodulize.camelize
-      end
+      GrapeSwagger::DocMethods::DataType.parse_entity_name(name)
     end
 
     def hidden?(route, options)
       route_hidden = route.options[:hidden]
       return route_hidden unless route_hidden.is_a?(Proc)
-      options[:oauth_token] ? route_hidden.call(send(options[:oauth_token].to_sym)) : route_hidden.call
+      options[:token_owner] ? route_hidden.call(send(options[:token_owner].to_sym)) : route_hidden.call
     end
 
     def public_parameter?(param)
       param_options = param.last
       return true unless param_options.key?(:documentation) && !param_options[:required]