grape-swagger 0.20.2 → 0.20.3

data/example/api/entities.rb

@@ -6,7 +6,7 @@ module Api
       expose :id, documentation: { type: Integer, desc: 'identity of a resource' }
       expose :x, documentation: { type: Float, desc: 'x-value' }
       expose :y, documentation: { type: Float, desc: 'y-value' }
-      expose :path, documentation: { type: String, desc: 'the requested resource'}
+      expose :path, documentation: { type: String, desc: 'the requested resource' }
 
       private
 

data/example/config.ru

@@ -31,14 +31,12 @@ class Base < Grape::API
     error_response(message: "Internal server error: #{e}", status: 500)
   end
 
-  add_swagger_documentation :hide_documentation_path => true,
-                            :api_version => 'v1',
-                            :info => {
-                              title: "Horses and Hussars",
-                              description: "Demo app for dev of grape swagger 2.0"
+  add_swagger_documentation hide_documentation_path: true,
+                            api_version: 'v1',
+                            info: {
+                              title: 'Horses and Hussars',
+                              description: 'Demo app for dev of grape swagger 2.0'
                             }
-
 end
 
-
 run Base.new

data/grape-swagger.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.summary     = 'A simple way to add auto generated documentation to your Grape API that can be displayed with Swagger.'
   s.license     = 'MIT'
 
-  s.add_runtime_dependency 'grape', ['>= 0.12.0', '<= 0.14.0']
+  s.add_runtime_dependency 'grape', '>= 0.12.0'
   s.add_runtime_dependency 'grape-entity'
   s.add_runtime_dependency 'awesome_print'
 

data/lib/grape-swagger.rb

@@ -1,4 +1,7 @@
 require 'grape'
+
+require 'grape-swagger/grape/route'
+
 require 'grape-swagger/version'
 require 'grape-swagger/endpoint'
 require 'grape-swagger/errors'
@@ -48,8 +51,8 @@ module Grape
 
       def combine_routes(app, doc_klass)
         app.routes.each do |route|
-          route_path = route.route_path
-          route_match = route_path.split(/^.*?#{route.route_prefix.to_s}/).last
+          route_path = route.path
+          route_match = route_path.split(/^.*?#{route.prefix.to_s}/).last
           next unless route_match
           route_match = route_match.match('\/([\w|-]*?)[\.\/\(]') || route_match.match('\/([\w|-]*)$')
           next unless route_match
@@ -57,7 +60,7 @@ module Grape
           next if resource.empty?
           resource.downcase!
           @target_class.combined_routes[resource] ||= []
-          next if doc_klass.hide_documentation_path && route.route_path.match(/#{doc_klass.mount_path}($|\/|\(\.)/)
+          next if doc_klass.hide_documentation_path && route.path.match(/#{doc_klass.mount_path}($|\/|\(\.)/)
           @target_class.combined_routes[resource] << route
         end
       end
@@ -141,10 +144,10 @@ module Grape
       end
 
       def route_path_start_with?(route, name)
-        route_prefix = route.route_prefix ? "/#{route.route_prefix}/#{name}" : "/#{name}"
-        route_versioned_prefix = route.route_prefix ? "/#{route.route_prefix}/:version/#{name}" : "/:version/#{name}"
+        route_prefix = route.prefix ? "/#{route.prefix}/#{name}" : "/#{name}"
+        route_versioned_prefix = route.prefix ? "/#{route.prefix}/:version/#{name}" : "/:version/#{name}"
 
-        route.route_path.start_with?(route_prefix, route_versioned_prefix)
+        route.path.start_with?(route_prefix, route_versioned_prefix)
       end
 
       def standalone_sub_namespaces(name, namespaces)

data/lib/grape-swagger/doc_methods.rb

@@ -91,7 +91,7 @@ module GrapeSwagger
       {
         info: {},
         models: [],
-        api_version: 'v1',
+        doc_version: '0.0.1',
         target_class: nil,
         mount_path: '/swagger_doc',
         host: nil,

data/lib/grape-swagger/doc_methods/extensions.rb

@@ -4,10 +4,10 @@ module GrapeSwagger
       class << self
         def add(path, definitions, route)
           @route = route
-          description = route.route_settings[:description]
+          description = route.settings[:description]
           add_extension_to(path[method], extension(description)) if description && extended?(description, :x)
 
-          settings = route.route_settings
+          settings = route.settings
           add_extensions_to_path(settings, path) if settings && extended?(settings, :x_path)
           add_extensions_to_definition(settings, path, definitions) if settings && extended?(settings, :x_def)
         end
@@ -67,7 +67,7 @@ module GrapeSwagger
         end
 
         def method
-          @route.route_method.downcase.to_sym
+          @route.request_method.downcase.to_sym
         end
       end
     end

data/lib/grape-swagger/doc_methods/headers.rb

@@ -3,7 +3,7 @@ module GrapeSwagger
     class Headers
       class << self
         def parse(route)
-          route.route_headers.to_a.map do |route_header|
+          route.headers.to_a.map do |route_header|
             route_header.tap do |header|
               hash = header[1]
               description = hash.delete('description')

data/lib/grape-swagger/doc_methods/move_params.rb

@@ -4,8 +4,12 @@ module GrapeSwagger
       class << self
         def to_definition(paths, definitions)
           @definitions = definitions
-          find_post_put(paths) do |path|
-            find_definition_and_params(path)
+
+          find_post_put(paths) do |method_definition|
+            verb = method_definition.keys.first
+            method_object = method_definition[verb]
+
+            find_definition_and_params(method_object, verb)
           end
         end
 
@@ -16,25 +20,29 @@ module GrapeSwagger
           end
         end
 
-        def find_definition_and_params(path)
-          path.keys.each do |verb|
-            params = path[verb][:parameters]
+        def find_definition_and_params(path, verb)
+          params = path[:parameters]
 
-            next if params.nil?
-            next unless should_move?(params)
+          return if params.nil?
+          return unless should_move?(params)
 
-            unify!(params)
+          unify!(params)
 
-            status_code = GrapeSwagger::DocMethods::StatusCodes.get[verb.to_sym][:code]
-            response = path[verb][:responses][status_code]
-            referenced_definition = parse_model(response[:schema]['$ref'])
+          status_code = GrapeSwagger::DocMethods::StatusCodes.get[verb.to_sym][:code]
+          response = path[:responses][status_code]
 
+          if response[:schema] && response[:schema]['$ref']
+            referenced_definition = parse_model(response[:schema]['$ref'])
             name = build_definition(referenced_definition, verb)
-            move_params_to_new(name, params)
-
-            @definitions[name][:description] = path[verb][:description]
-            path[verb][:parameters] << build_body_parameter(response.dup, name)
+          else
+            referenced_definition = path[:operationId]
+            name = build_definition(referenced_definition)
           end
+
+          move_params_to_new(name, params)
+
+          @definitions[name][:description] = path[:description]
+          path[:parameters] << build_body_parameter(response.dup, name)
         end
 
         def move_params_to_new(name, params)
@@ -88,9 +96,10 @@ module GrapeSwagger
         private
 
         def build_body_parameter(response, name = false)
+          entity = response[:schema] ? parse_model(response[:schema]['$ref']) : name
           body_param = {}
           body_param.tap do |x|
-            x[:name] = parse_model(response[:schema]['$ref'])
+            x[:name] = entity
             x[:in] = 'body'
             x[:required] = true
             x[:schema] = { '$ref' => response[:schema]['$ref'] } unless name

data/lib/grape-swagger/doc_methods/operation_id.rb

@@ -2,8 +2,8 @@ module GrapeSwagger
   module DocMethods
     class OperationId
       class << self
-        def build(method = nil, path = nil)
-          verb = method.to_s.downcase
+        def build(route, path = nil)
+          verb = route.request_method.to_s.downcase
 
           operation = manipulate(path) unless path.nil?
 

data/lib/grape-swagger/doc_methods/parse_params.rb

@@ -3,8 +3,8 @@ module GrapeSwagger
     class ParseParams
       class << self
         def call(param, settings, route)
-          path = route.route_path
-          method = route.route_method
+          path = route.path
+          method = route.request_method
 
           data_type = GrapeSwagger::DocMethods::DataType.call(settings)
           additional_documentation = settings[:documentation]
@@ -14,12 +14,14 @@ module GrapeSwagger
 
           value_type = settings.merge(data_type: data_type, path: path, param_name: param, method: method)
 
+          # required properties
           @parsed_param = {
-            in:            param_type(value_type),
-            name:          settings[:full_name] || param,
-            description:   settings[:desc] || settings[:description] || nil
+            in:   param_type(value_type),
+            name: settings[:full_name] || param
           }
 
+          # optional properties
+          document_description(settings)
           document_type_and_format(data_type)
           document_array_param(value_type)
           document_default_value(settings)
@@ -31,6 +33,11 @@ module GrapeSwagger
 
         private
 
+        def document_description(settings)
+          description = settings[:desc] || settings[:description]
+          @parsed_param[:description] = description if description
+        end
+
         def document_required(settings)
           @parsed_param[:required] = settings[:required] || false
           @parsed_param[:required] = true if @parsed_param[:in] == 'path'

data/lib/grape-swagger/doc_methods/path_string.rb

@@ -14,7 +14,7 @@ module GrapeSwagger
           item = path.gsub(%r{/{(.+?)}}, '').split('/').last.singularize.underscore.camelize || 'Item'
 
           if options[:version] && options[:add_version]
-            path.sub!('{version}', options[:version])
+            path.sub!('{version}', options[:version].to_s)
           else
             path.sub!('/{version}', '')
           end

data/lib/grape-swagger/doc_methods/status_codes.rb

@@ -8,7 +8,9 @@ module GrapeSwagger
             post: { code: 201, message: 'created {item}' },
             put: { code: 200, message: 'updated {item}' },
             patch: { code: 200, message: 'patched {item}' },
-            delete: { code: 200, message: 'deleted {item}' }
+            delete: { code: 200, message: 'deleted {item}' },
+            head: { code: 200, message: 'head {item}' },
+            options: { code: 200, message: 'option {item}' }
           }
         end
       end

data/lib/grape-swagger/doc_methods/tag_name_description.rb

@@ -8,7 +8,7 @@ module GrapeSwagger
           namespace_routes = target_class.combined_namespace_routes
 
           namespace_routes.keys.map do |local_route|
-            next if namespace_routes[local_route].map(&:route_hidden).all? { |value| value.respond_to?(:call) ? value.call : value }
+            next if namespace_routes[local_route].map { |route| route.options[:hidden] }.all? { |value| value.respond_to?(:call) ? value.call : value }
 
             original_namespace_name = target_class.combined_namespace_identifiers.key?(local_route) ? target_class.combined_namespace_identifiers[local_route] : local_route
             description = namespaces[original_namespace_name] && namespaces[original_namespace_name].options[:desc]

data/lib/grape-swagger/endpoint.rb

@@ -20,7 +20,7 @@ module Grape
     # required keys for SwaggerObject
     def swagger_object(target_class, request, options)
       {
-        info:           info_object(options[:info].merge(version: options[:api_version])),
+        info:           info_object(options[:info].merge(version: options[:doc_version])),
         swagger:        '2.0',
         produces:       content_types_for(target_class),
         authorizations: options[:authorizations],
@@ -86,19 +86,18 @@ module Grape
       routes.each do |route|
         next if hidden?(route)
 
-        @item, path = GrapeSwagger::DocMethods::PathString.build(route.route_path, options)
-        @entity = route.route_entity || route.route_success
+        @item, path = GrapeSwagger::DocMethods::PathString.build(route.path, options)
+        @entity = route.entity || route.options[:success]
 
-        method = route.route_method.downcase.to_sym
-        request_params = method_object(route, options, path)
+        verb, method_object = method_object(route, options, path)
 
-        if @paths.key?(path.to_sym)
-          @paths[path.to_sym][method] = request_params
+        if @paths.key?(path.to_s)
+          @paths[path.to_s][verb] = method_object
         else
-          @paths[path.to_sym] = { method => request_params }
+          @paths[path.to_s] = { verb => method_object }
         end
 
-        GrapeSwagger::DocMethods::Extensions.add(@paths[path.to_sym], @definitions, route)
+        GrapeSwagger::DocMethods::Extensions.add(@paths[path.to_s], @definitions, route)
       end
     end
 
@@ -109,16 +108,18 @@ module Grape
       method[:consumes]    = consumes_object(route, options[:format])
       method[:parameters]  = params_object(route)
       method[:responses]   = response_object(route, options[:markdown])
-      method[:tags]        = tag_object(route, options[:version])
-      method[:operationId] = GrapeSwagger::DocMethods::OperationId.build(route.route_method, path)
+      method[:tags]        = tag_object(route, options[:version].to_s)
+      method[:operationId] = GrapeSwagger::DocMethods::OperationId.build(route, path)
       method.delete_if { |_, value| value.blank? }
+
+      [route.request_method.downcase.to_sym, method]
     end
 
     def description_object(route, markdown)
-      description = route.route_desc if route.route_desc.present?
-      description = route.route_description if route.route_description.present?
+      description = route.options[:desc] if route.options.key?(:desc)
+      description = route.description if route.description.present?
       description = "# #{description} " if markdown
-      description += "\n #{route.route_detail}" if route.route_detail
+      description += "\n #{route.options[:detail]}" if route.options.key?(:detail)
       description = markdown.markdown(description.to_s).chomp if markdown
 
       description
@@ -127,8 +128,8 @@ module Grape
     def produces_object(route, format)
       mime_types = GrapeSwagger::DocMethods::ProducesConsumes.call(format)
 
-      route_mime_types = [:route_formats, :route_content_types, :route_produces].map do |producer|
-        possible = route.send(producer)
+      route_mime_types = [:formats, :content_types, :produces].map do |producer|
+        possible = route.options[producer]
         GrapeSwagger::DocMethods::ProducesConsumes.call(possible) if possible.present?
       end.flatten.compact.uniq
 
@@ -136,8 +137,8 @@ module Grape
     end
 
     def consumes_object(route, format)
-      method = route.route_method.downcase.to_sym
-      format = route.route_settings[:description][:consumes] if route.route_settings[:description] && route.route_settings[:description][:consumes]
+      method = route.request_method.downcase.to_sym
+      format = route.settings[:description][:consumes] if route.settings[:description] && route.settings[:description][:consumes]
       mime_types = GrapeSwagger::DocMethods::ProducesConsumes.call(format) if [:post, :put].include?(method)
 
       mime_types
@@ -152,11 +153,11 @@ module Grape
     end
 
     def response_object(route, markdown)
-      default_code = GrapeSwagger::DocMethods::StatusCodes.get[route.route_method.downcase.to_sym]
+      default_code = GrapeSwagger::DocMethods::StatusCodes.get[route.request_method.downcase.to_sym]
       default_code[:model] = @entity if @entity
-      default_code[:message] = route.route_description || default_code[:message].sub('{item}', @item)
+      default_code[:message] = route.description || default_code[:message].sub('{item}', @item)
 
-      codes = [default_code] + (route.route_http_codes || route.route_failure || [])
+      codes = [default_code] + (route.http_codes || route.options[:failure] || [])
       codes.map! { |x| x.is_a?(Array) ? { code: x[0], message: x[1], model: x[2] } : x }
 
       codes.each_with_object({}) do |value, memo|
@@ -165,7 +166,7 @@ module Grape
         response_model = @item
         response_model = expose_params_from_model(value[:model]) if value[:model]
 
-        if memo.key?(200) && route.route_method == 'DELETE' && value[:model].nil?
+        if memo.key?(200) && route.request_method == 'DELETE' && value[:model].nil?
           memo[204] = memo.delete(200)
           value[:code] = 204
         end
@@ -176,7 +177,7 @@ module Grape
 
         @definitions[response_model][:description] = description_object(route, markdown)
         # TODO: proof that the definition exist, if model isn't specified
-        memo[value[:code]][:schema] = if route.route_is_array
+        memo[value[:code]][:schema] = if route.options[:is_array]
                                         { 'type' => 'array', 'items' => { '$ref' => "#/definitions/#{response_model}" } }
                                       else
                                         { '$ref' => "#/definitions/#{response_model}" }
@@ -185,35 +186,23 @@ module Grape
     end
 
     def tag_object(route, version)
-      Array(route.route_path.split('{')[0].split('/').reject(&:empty?).delete_if { |i| ((i == route.route_prefix.to_s) || (i == version)) }.first)
+      Array(route.path.split('{')[0].split('/').reject(&:empty?).delete_if { |i| ((i == route.prefix.to_s) || (i == version)) }.first)
     end
 
     private
 
     def partition_params(route)
-      declared_params = route.route_settings[:declared_params] if route.route_settings[:declared_params].present?
-      required, exposed = route.route_params.partition { |x| x.first.is_a? String }
-      required.concat GrapeSwagger::DocMethods::Headers.parse(route) unless route.route_headers.nil?
+      declared_params = route.settings[:declared_params] if route.settings[:declared_params].present?
+      required, exposed = route.params.partition { |x| x.first.is_a? String }
+      required.concat GrapeSwagger::DocMethods::Headers.parse(route) unless route.headers.nil?
       default_type(required)
       default_type(exposed)
 
-      unless declared_params.nil? && route.route_headers.nil?
+      unless declared_params.nil? && route.headers.nil?
         request_params = parse_request_params(required)
       end
-      if !exposed.empty?
-        exposed_params = exposed.each_with_object({}) { |x, memo| memo[x.first] = x.last }
-        properties = parse_response_params(exposed_params)
-      else
-        properties = parse_response_params(required)
-      end
-
-      key = model_name(@entity || @item)
 
-      unless properties.empty? || (route.route_method == 'DELETE' && !@entity)
-        @definitions[key] = { type: 'object', properties: properties } unless @definitions.key?(key)
-        @definitions[key][:properties].merge!(properties) if @definitions.key?(key)
-      end
-      return route.route_params if route.route_params.present? && !route.route_settings[:declared_params].present?
+      return route.params if route.params.present? && !route.settings[:declared_params].present?
       request_params || {}
     end
 
@@ -306,11 +295,9 @@ module Grape
     end
 
     def hidden?(route)
-      if route.route_hidden
-        return route.route_hidden.is_a?(Proc) ? route.route_hidden.call : route.route_hidden
-      end
-
-      false
+      route_hidden = route.options[:hidden]
+      route_hidden = route_hidden.call if route_hidden.is_a?(Proc)
+      route_hidden
     end
   end
 end