grape-swagger 0.26.0 → 0.26.1

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

@@ -20,7 +20,7 @@ module GrapeSwagger
 
           # optional properties
           document_description(settings)
-          document_type_and_format(data_type)
+          document_type_and_format(settings, data_type)
           document_array_param(value_type, definitions) if value_type[:is_array]
           document_default_value(settings)
           document_range_values(settings)
@@ -51,13 +51,14 @@ module GrapeSwagger
           @parsed_param[:default] = settings[:default] if settings[:default].present?
         end
 
-        def document_type_and_format(data_type)
+        def document_type_and_format(settings, data_type)
           if DataType.primitive?(data_type)
             data = DataType.mapping(data_type)
             @parsed_param[:type], @parsed_param[:format] = data
           else
             @parsed_param[:type] = data_type
           end
+          @parsed_param[:format] = settings[:format] if settings[:format].present?
         end
 
         def document_array_param(value_type, definitions)
@@ -99,15 +100,10 @@ module GrapeSwagger
 
         def parse_enum_or_range_values(values)
           case values
+          when Proc
+            parse_enum_or_range_values(values.call)
           when Range
             parse_range_values(values) if values.first.is_a?(Integer)
-          when Proc
-            values_result = values.call
-            if values_result.is_a?(Range) && values_result.first.is_a?(Integer)
-              parse_range_values(values_result)
-            else
-              { enum: values_result }
-            end
           else
             { enum: values } if values
           end

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

@@ -4,14 +4,27 @@ module GrapeSwagger
       class << self
         def build(paths)
           paths.values.each_with_object([]) do |path, memo|
-            path.values.first[:tags].each do |tag|
-              memo << {
-                name: tag,
-                description: "Operations about #{tag.pluralize}"
-              }
+            tags = path.values.first[:tags]
+
+            case tags
+            when String
+              memo << build_memo(tags)
+            when Array
+              path.values.first[:tags].each do |tag|
+                memo << build_memo(tag)
+              end
             end
           end.uniq
         end
+
+        private
+
+        def build_memo(tag)
+          {
+            name: tag,
+            description: "Operations about #{tag.pluralize}"
+          }
+        end
       end
     end
   end

data/lib/grape-swagger/endpoint.rb

@@ -8,7 +8,7 @@ module Grape
 
       if content_types.empty?
         formats       = [target_class.format, target_class.default_format].compact.uniq
-        formats       = Grape::Formatter::Base.formatters({}).keys if formats.empty?
+        formats       = Grape::Formatter.formatters({}).keys if formats.empty?
         content_types = Grape::ContentTypes::CONTENT_TYPES.select do |content_type, _mime_type|
           formats.include? content_type
         end.values
@@ -105,12 +105,12 @@ module Grape
     def method_object(route, options, path)
       method = {}
       method[:summary]     = summary_object(route)
-      method[:description] = description_object(route, options[:markdown])
+      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[:security]    = security_object(route)
-      method[:responses]   = response_object(route, options[:markdown])
+      method[:responses]   = response_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? }
@@ -130,10 +130,9 @@ module Grape
       summary
     end
 
-    def description_object(route, markdown)
+    def description_object(route)
       description = route.description if route.description.present?
       description = route.options[:detail] if route.options.key?(:detail)
-      description = markdown.markdown(description.to_s).chomp if markdown
 
       description
     end
@@ -178,7 +177,7 @@ module Grape
       parameters
     end
 
-    def response_object(route, markdown)
+    def response_object(route)
       codes = (route.http_codes || route.options[:failure] || [])
 
       codes = apply_success_codes(route) + codes
@@ -196,13 +195,12 @@ module Grape
         end
 
         next if memo.key?(204)
-        next unless !response_model.start_with?('Swagger_doc') &&
-                    ((@definitions[response_model] && value[:code].to_s.start_with?('2')) || value[:model])
+        next unless !response_model.start_with?('Swagger_doc') && (@definitions[response_model] || value[:model])
 
-        @definitions[response_model][:description] = description_object(route, markdown)
+        @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]
+        memo[value[:code]][:schema] = if route.options[:is_array] && value[:code] < 300
                                         { 'type' => 'array', 'items' => reference }
                                       else
                                         reference

data/lib/grape-swagger/errors.rb

@@ -1,12 +1,13 @@
 module GrapeSwagger
   module Errors
-    class MarkdownDependencyMissingError < StandardError
-      def initialize(missing_gem)
-        super("Missing required dependency: #{missing_gem}")
-      end
-    end
-
     class UnregisteredParser < StandardError; end
     class SwaggerSpec < StandardError; end
+    class SwaggerSpecDeprecated < SwaggerSpec
+      class << self
+        def tell!(what)
+          warn "[GrapeSwagger] usage of #{what} is deprecated"
+        end
+      end
+    end
   end
 end

data/lib/grape-swagger/rake/oapi_tasks.rb

@@ -35,9 +35,11 @@ module GrapeSwagger
           store    – save as JSON file, default: false            (optional)
           resource - if given only for that it would be generated (optional)'
         task fetch: :environment do
+          # :nocov:
           make_request
 
           save_to_file? ? File.write(file, @oapi) : $stdout.print(@oapi)
+          # :nocov:
         end
       end
 
@@ -47,6 +49,7 @@ module GrapeSwagger
           params (usage: key=value):
           resource - if given only for that it would be generated (optional)'
         task validate: :environment do
+          # :nocov:
           ENV['store'] = 'true'
           ::Rake::Task['oapi:fetch'].invoke
           exit if error?
@@ -55,6 +58,7 @@ module GrapeSwagger
 
           $stdout.puts 'install swagger-cli with `npm install swagger-cli -g`' if output.nil?
           FileUtils.rm(file)
+          # :nocov:
         end
       end
 
@@ -62,7 +66,7 @@ module GrapeSwagger
       #
       def make_request
         get url_for
-        last_response
+
         @oapi = JSON.pretty_generate(
           JSON.parse(
             last_response.body, symolize_names: true

data/lib/grape-swagger/version.rb

@@ -1,3 +1,3 @@
 module GrapeSwagger
-  VERSION = '0.26.0'.freeze
+  VERSION = '0.26.1'.freeze
 end

data/spec/issues/532_allow_custom_format_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe '#542 array of type in post params' do
+  let(:app) do
+    Class.new(Grape::API) do
+      namespace :issue_532 do
+        params do
+          requires :logs, type: String, documentation: { format: 'log' }
+          optional :phone_number, type: Integer, documentation: { format: 'phone_number' }
+        end
+
+        post do
+          present params
+        end
+      end
+
+      add_swagger_documentation format: :json
+    end
+  end
+
+  subject do
+    get '/swagger_doc'
+    JSON.parse(last_response.body)
+  end
+
+  let(:parameters) { subject['paths']['/issue_532']['post']['parameters'] }
+
+  specify do
+    expect(parameters).to eql(
+      [
+        { 'in' => 'formData', 'name' => 'logs', 'type' => 'string', 'format' => 'log', 'required' => true },
+        { 'in' => 'formData', 'name' => 'phone_number', 'type' => 'integer', 'format' => 'phone_number', 'required' => false }
+      ]
+    )
+  end
+end

data/spec/issues/537_enum_values_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe '#537 enum values spec' do
+  let(:app) do
+    Class.new(Grape::API) do
+      namespace :issue_539 do
+        class Spec < Grape::Entity
+          expose :enum_property, documentation: { values: [:foo, :bar] }
+          expose :enum_property_default, documentation: { values: %w(a b c), default: 'c' }
+          expose :own_format, documentation: { format: 'log' }
+        end
+
+        desc 'create account',
+             success: Spec
+        get do
+        end
+      end
+
+      add_swagger_documentation format: :json
+    end
+  end
+
+  subject do
+    get '/swagger_doc'
+    JSON.parse(last_response.body)
+  end
+
+  let(:property) { subject['definitions']['Spec']['properties']['enum_property'] }
+  specify do
+    expect(property).to include 'enum'
+    expect(property['enum']).to eql %w(foo bar)
+  end
+
+  let(:property_default) { subject['definitions']['Spec']['properties']['enum_property_default'] }
+  specify do
+    expect(property_default).to include 'enum'
+    expect(property_default['enum']).to eql %w(a b c)
+    expect(property_default).to include 'default'
+    expect(property_default['default']).to eql 'c'
+  end
+
+  let(:own_format) { subject['definitions']['Spec']['properties']['own_format'] }
+  specify do
+    expect(own_format).to include 'format'
+    expect(own_format['format']).to eql 'log'
+  end
+end

data/spec/issues/572_array_post_body_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe '#572 is_array is applied to all possible responses' do
+  include_context "#{MODEL_PARSER} swagger example"
+
+  let(:app) do
+    Class.new(Grape::API) do
+      namespace :issue_572 do
+        desc 'get issue',
+             is_array: true,
+             success: Entities::UseResponse,
+             failure: [
+               [401, 'BadKittenError', Entities::ApiError],
+               [404, 'NoTreatsError', Entities::ApiError],
+               [429, 'TooManyScratchesError', Entities::ApiError]
+             ]
+
+        get
+      end
+
+      add_swagger_documentation format: :json
+    end
+  end
+
+  subject do
+    get '/swagger_doc'
+    JSON.parse(last_response.body)
+  end
+
+  let(:codes) { %w(200 401 404 429) }
+
+  let(:responses) { subject['paths']['/issue_572']['get']['responses'] }
+
+  specify { expect(responses.keys.sort).to eq codes }
+
+  specify do
+    expect(responses['200']['schema']).to include 'type'
+    expect(responses['200']['schema']['type']).to eql 'array'
+  end
+
+  describe 'no array types' do
+    specify do
+      codes[1..-1].each do |code|
+        expect(responses[code]['schema']).not_to include 'type'
+        expect(responses[code]['schema'].keys).to eql ['$ref']
+      end
+    end
+  end
+end

data/spec/lib/endpoint_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe Grape::Endpoint do
-  subject { described_class.new(Grape::Util::InheritableSetting.new, path: '/', method: :get) }
+  subject do
+    described_class.new(Grape::Util::InheritableSetting.new, path: '/', method: :get)
+  end
 
   describe '#param_type_is_array?' do
     it 'returns true if the value passed represents an array' do
@@ -15,4 +17,43 @@ describe Grape::Endpoint do
       expect(subject.send(:param_type_is_array?, '[String, Integer]')).to be_falsey
     end
   end
+
+  describe '.content_types_for' do
+    describe 'defined on target_class' do
+      let(:own_json) { 'text/own-json' }
+      let(:own_xml) { 'text/own-xml' }
+      let(:content_types) do
+        {
+          own_json: own_json,
+          own_xml: own_xml
+        }
+      end
+      let(:target_class) { OpenStruct.new(content_types: content_types) }
+
+      let(:object) { subject.content_types_for(target_class) }
+      specify do
+        expect(object).to eql [own_json, own_xml]
+      end
+    end
+
+    describe 'not defined' do
+      describe 'format given' do
+        let(:format) { :json }
+        let(:target_class) { OpenStruct.new(format: format) }
+        let(:object) { subject.content_types_for(target_class) }
+        specify do
+          expect(object).to eql ['application/json']
+        end
+
+        describe 'format not given' do
+          let(:target_class) { OpenStruct.new }
+          let(:object) { subject.content_types_for(target_class) }
+
+          specify do
+            expect(object).to eql %w(application/xml application/json text/plain)
+          end
+        end
+      end
+    end
+  end
 end

data/spec/lib/extensions_spec.rb

@@ -1,6 +1,48 @@
 require 'spec_helper'
 
 describe GrapeSwagger::DocMethods::Extensions do
+  describe '#find_definition' do
+    subject { described_class }
+
+    let(:method) { :get }
+    let(:status) { 200 }
+
+    before { allow(subject).to receive(:method).and_return(method) }
+
+    describe 'no response for status' do
+      let(:path) { { get: { responses: {} } } }
+
+      specify do
+        definition = subject.find_definition(status, path)
+        expect(definition).to be_nil
+      end
+    end
+
+    describe 'response found' do
+      let(:model) { 'Item' }
+
+      describe 'ref given' do
+        let(:path) do
+          { get: { responses: { 200 => { schema: { '$ref' => "#/definitions/#{model}" } } } } }
+        end
+        specify do
+          definition = subject.find_definition(status, path)
+          expect(definition).to eql model
+        end
+      end
+
+      describe 'items given' do
+        let(:path) do
+          { get: { responses: { 200 => { schema: { 'items' => { '$ref' => "#/definitions/#{model}" } } } } } }
+        end
+        specify do
+          definition = subject.find_definition(status, path)
+          expect(definition).to eql model
+        end
+      end
+    end
+  end
+
   describe '#extended? and extension' do
     subject { described_class }
     describe 'return false (default)' do

data/spec/lib/oapi_tasks_spec.rb

@@ -5,11 +5,11 @@ RSpec.describe GrapeSwagger::Rake::OapiTasks do
     item = Class.new(Grape::API) do
       version 'v1', using: :path
 
-      resource :item do
+      namespace :item do
         get '/'
       end
 
-      resource :otherItem do
+      namespace :otherItem do
         get '/'
       end
     end
@@ -100,6 +100,17 @@ RSpec.describe GrapeSwagger::Rake::OapiTasks do
         end
       end
     end
+
+    describe 'call it' do
+      before do
+        subject.send(:make_request)
+      end
+      specify do
+        expect(subject).to respond_to :oapi
+        expect(subject.oapi).to be_a String
+        expect(subject.oapi).not_to be_empty
+      end
+    end
   end
 
   describe '#file' do