grape-swagger 0.20.3 → 0.21.0

data/lib/grape-swagger/endpoint.rb

@@ -24,8 +24,8 @@ module Grape
         swagger:        '2.0',
         produces:       content_types_for(target_class),
         authorizations: options[:authorizations],
-        host:           GrapeSwagger::DocMethods::OptionalObject.build(:host, options, request.host_with_port),
-        basePath:       GrapeSwagger::DocMethods::OptionalObject.build(:base_path, options, request.env['SCRIPT_NAME']),
+        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? }
@@ -86,7 +86,7 @@ module Grape
       routes.each do |route|
         next if hidden?(route)
 
-        @item, path = GrapeSwagger::DocMethods::PathString.build(route.path, options)
+        @item, path = GrapeSwagger::DocMethods::PathString.build(route, options)
         @entity = route.entity || route.options[:success]
 
         verb, method_object = method_object(route, options, path)
@@ -103,6 +103,7 @@ module Grape
 
     def method_object(route, options, path)
       method = {}
+      method[:summary]     = summary_object(route)
       method[:description] = description_object(route, options[:markdown])
       method[:produces]    = produces_object(route, options[:produces] || options[:format])
       method[:consumes]    = consumes_object(route, options[:format])
@@ -115,6 +116,14 @@ module Grape
       [route.request_method.downcase.to_sym, method]
     end
 
+    def summary_object(route)
+      summary = route.options[:desc] if route.options.key?(:desc)
+      summary = route.description if route.description.present?
+      summary = route.options[:summary] if route.options.key?(:summary)
+
+      summary
+    end
+
     def description_object(route, markdown)
       description = route.options[:desc] if route.options.key?(:desc)
       description = route.description if route.description.present?
@@ -226,53 +235,25 @@ module Grape
       end
     end
 
-    def parse_response_params(params)
-      return if params.nil?
+    def expose_params_from_model(model)
+      model_name = model_name(model)
 
-      params.each_with_object({}) do |x, memo|
-        next if x[1].fetch(:documentation, {}).fetch(:in, nil).to_s == 'header'
-        x[0] = x.last[:as] if x.last[:as]
+      return model_name if @definitions.key?(model_name)
+      @definitions[model_name] = nil
 
-        model = x.last[:using] if x.last[:using].present?
-        model ||= x.last[:documentation][:type] if x.last[:documentation] && could_it_be_a_model?(x.last[:documentation])
+      properties = nil
+      parser = nil
 
-        if model
-          name = expose_params_from_model(model)
-          memo[x.first] = if x.last[:documentation] && x.last[:documentation][:is_array]
-                            { 'type' => 'array', 'items' => { '$ref' => "#/definitions/#{name}" } }
-                          else
-                            { '$ref' => "#/definitions/#{name}" }
-                          end
-        else
-          documented_type = x.last[:type]
-          documented_type ||= x.last[:documentation][:type] if x.last[:documentation]
-          data_type = GrapeSwagger::DocMethods::DataType.call(documented_type)
-
-          if GrapeSwagger::DocMethods::DataType.primitive?(data_type)
-            data = GrapeSwagger::DocMethods::DataType.mapping(data_type)
-            memo[x.first] = { type: data.first, format: data.last }
-          else
-            memo[x.first] = { type: data_type }
-          end
-
-          memo[x.first][:enum] = x.last[:values] if x.last[:values] && x.last[:values].is_a?(Array)
-        end
-        memo[x.first][:description] = x.last[:documentation][:desc] if x.last[:documentation] && x.last[:documentation][:desc]
+      GrapeSwagger.model_parsers.each do |klass, ancestor|
+        next unless model.ancestors.map(&:to_s).include?(ancestor)
+        parser = klass.new(model, self)
+        break
       end
-    end
 
-    def expose_params_from_model(model)
-      model_name = model_name(model)
+      properties = parser.call unless parser.nil?
 
-      # TODO: this should only be a temporary hack ;)
-      if GrapeEntity::VERSION =~ /0\.4\.\d/
-        parameters = model.exposures ? model.exposures : model.documentation
-      elsif GrapeEntity::VERSION =~ /0\.5\.\d/
-        parameters = model.root_exposures.each_with_object({}) do |value, memo|
-          memo[value.attribute] = value.send(:options)
-        end
-      end
-      properties = parse_response_params(parameters)
+      raise GrapeSwagger::Errors::UnregisteredParser, "No parser registered for #{model_name}." unless parser
+      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 }
 
@@ -283,17 +264,6 @@ module Grape
       name.respond_to?(:name) ? name.name.demodulize.camelize : name.split('::').last
     end
 
-    def could_it_be_a_model?(value)
-      (
-        value[:type].to_s.include?('Entity') || value[:type].to_s.include?('Entities')
-      ) || (
-        value[:type] &&
-        value[:type].is_a?(Class) &&
-        !GrapeSwagger::DocMethods::DataType.primitive?(value[:type].name.downcase) &&
-        !value[:type] == Array
-      )
-    end
-
     def hidden?(route)
       route_hidden = route.options[:hidden]
       route_hidden = route_hidden.call if route_hidden.is_a?(Proc)

data/lib/grape-swagger/errors.rb

@@ -5,5 +5,8 @@ module GrapeSwagger
         super("Missing required dependency: #{missing_gem}")
       end
     end
+
+    class UnregisteredParser < StandardError; end
+    class SwaggerSpec < StandardError; end
   end
 end

data/lib/grape-swagger/grape/route.rb

@@ -1,7 +1,8 @@
 # backwards compatibility for Grape < 0.16.0
 module Grape
   class Route
-    [:path, :prefix, :entity, :description, :settings, :params, :headers, :http_codes].each do |m|
+    [:path, :prefix, :entity, :description, :settings, :params, :headers, :http_codes, :version]
+      .each do |m|
       define_method m do
         send "route_#{m}"
       end

data/lib/grape-swagger/model_parsers.rb

@@ -0,0 +1,33 @@
+module GrapeSwagger
+  class ModelParsers
+    include Enumerable
+
+    def initialize
+      @parsers = {}
+    end
+
+    def register(klass, ancestor)
+      @parsers[klass] = ancestor.to_s
+    end
+
+    def insert_before(before_klass, klass, ancestor)
+      subhash = @parsers.except(klass).to_a
+      insert_at = subhash.index(subhash.assoc(before_klass))
+      insert_at = subhash.length - 1 if insert_at.nil?
+      @parsers = Hash[subhash.insert(insert_at, [klass, ancestor])]
+    end
+
+    def insert_after(after_klass, klass, ancestor)
+      subhash = @parsers.except(klass).to_a
+      insert_at = subhash.index(subhash.assoc(after_klass))
+      insert_at = subhash.length - 1 if insert_at.nil?
+      @parsers = Hash[subhash.insert(insert_at + 1, [klass, ancestor])]
+    end
+
+    def each
+      @parsers.each_pair do |klass, ancestor|
+        yield klass, ancestor
+      end
+    end
+  end
+end

data/lib/grape-swagger/version.rb

@@ -1,3 +1,3 @@
 module GrapeSwagger
-  VERSION = '0.20.3'.freeze
+  VERSION = '0.21.0'.freeze
 end

data/spec/issues/403_versions_spec.rb

@@ -29,6 +29,7 @@ describe 'describing versions' do
         paths: {
           :'/nothings' => {
             get: {
+              summary: 'no versions given',
               description: 'no versions given',
               produces: ['application/json'],
               responses: {
@@ -36,7 +37,10 @@ describe 'describing versions' do
               },
               tags: ['nothings'],
               operationId: 'getNothings'
-            } } })
+            }
+          }
+        }
+      )
     end
   end
 
@@ -68,6 +72,7 @@ describe 'describing versions' do
         paths: {
           :'/v2/api_version' => {
             get: {
+              summary: 'api versions given',
               description: 'api versions given',
               produces: ['application/json'],
               responses: {
@@ -75,7 +80,10 @@ describe 'describing versions' do
               },
               tags: ['api_version'],
               operationId: 'getV2ApiVersion'
-            } } })
+            }
+          }
+        }
+      )
     end
   end
 
@@ -106,6 +114,7 @@ describe 'describing versions' do
         paths: {
           :'/doc_version' => {
             get: {
+              summary: 'doc versions given',
               description: 'doc versions given',
               produces: ['application/json'],
               responses: {
@@ -113,7 +122,10 @@ describe 'describing versions' do
               },
               tags: ['doc_version'],
               operationId: 'getDocVersion'
-            } } })
+            }
+          }
+        }
+      )
     end
   end
 
@@ -145,6 +157,7 @@ describe 'describing versions' do
         paths: {
           :'/v2/both_versions' => {
             get: {
+              summary: 'both versions given',
               description: 'both versions given',
               produces: ['application/json'],
               responses: {
@@ -152,7 +165,10 @@ describe 'describing versions' do
               },
               tags: ['both_versions'],
               operationId: 'getV2BothVersions'
-            } } })
+            }
+          }
+        }
+      )
     end
   end
 end

data/spec/lib/model_parsers_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe GrapeSwagger::ModelParsers do
+  let(:model_parsers) { described_class.new }
+  let(:parser) { Class.new }
+  let(:parser2) { Class.new }
+  let(:parser3) { Class.new }
+
+  describe '#register' do
+    describe 'successfully register new parser' do
+      before do
+        model_parsers.register(parser, Class)
+      end
+
+      specify do
+        expect(model_parsers.to_a).to eq([[parser, 'Class']])
+      end
+    end
+
+    describe 'should be empty if no registered parsers' do
+      specify do
+        expect(model_parsers.to_a).to be_empty
+      end
+    end
+  end
+
+  describe '#insert_before' do
+    describe 'SomeModelParser2 should be first parser' do
+      before do
+        model_parsers.register(parser, Class)
+        model_parsers.register(parser3, Class)
+        model_parsers.insert_before(parser, parser2, Class)
+      end
+
+      specify do
+        expect(model_parsers.count).to eq(3)
+        expect(model_parsers.to_a.first).to eq([parser2, Class])
+      end
+    end
+
+    describe 'SomeModelParser2 should be inserted anyway if SomeModelParser not registered' do
+      before do
+        model_parsers.register(parser3, Class)
+        model_parsers.insert_before(parser, parser2, Class)
+      end
+
+      specify do
+        expect(model_parsers.count).to eq(2)
+        expect(model_parsers.to_a).to include([parser2, Class])
+      end
+    end
+
+    describe 'SomeModelParser2 should be inserted anyway if model parsers is empty' do
+      before do
+        model_parsers.insert_before(parser, parser2, Class)
+      end
+
+      specify do
+        expect(model_parsers.count).to eq(1)
+        expect(model_parsers.to_a).to include([parser2, Class])
+      end
+    end
+  end
+
+  describe '#insert_after' do
+    describe 'SomeModelParser2 should be second parser' do
+      before do
+        model_parsers.register(parser, Class)
+        model_parsers.register(parser3, Class)
+        model_parsers.insert_after(parser, parser2, Class)
+      end
+
+      specify do
+        expect(model_parsers.count).to eq(3)
+        expect(model_parsers.to_a[1]).to eq([parser2, Class])
+      end
+    end
+
+    describe 'SomeModelParser2 should be inserted anyway if SomeModelParser not registered' do
+      before do
+        model_parsers.register(parser3, Class)
+        model_parsers.insert_after(parser, parser2, Class)
+      end
+
+      specify do
+        expect(model_parsers.count).to eq(2)
+        expect(model_parsers.to_a).to include([parser2, Class])
+      end
+    end
+
+    describe 'SomeModelParser2 should be inserted anyway if model parsers is empty' do
+      before do
+        model_parsers.insert_after(parser, parser2, Class)
+      end
+
+      specify do
+        expect(model_parsers.count).to eq(1)
+        expect(model_parsers.to_a).to include([parser2, Class])
+      end
+    end
+  end
+end

data/spec/lib/optional_object_spec.rb

@@ -7,33 +7,37 @@ describe GrapeSwagger::DocMethods::OptionalObject do
   specify { expect(subject).to respond_to :build }
 
   describe 'build' do
-    let(:key) { :bar }
-    let(:request) { 'somes/request/string' }
+    let(:key) { :host }
+    let!(:request) { Rack::Request.new(Rack::MockRequest.env_for('http://example.com:8080/')) }
 
-    describe 'no option given for key' do
+    describe 'no option given for host, take from request' do
       let(:options) { { foo: 'foo' } }
       specify do
-        expect(subject.build(key, options)).to be_nil
-        expect(subject.build(key, options, request)).to eql request
+        expect(subject.build(key, options, request)).to eql request.host_with_port
       end
     end
 
-    let(:value) { 'some optional value' }
+    let(:value) { 'grape-swagger.example.com' }
 
     describe 'option is a string' do
-      let(:options) { { bar: value } }
+      let(:options) { { host: value } }
       specify do
-        expect(subject.build(key, options)).to eql value
         expect(subject.build(key, options, request)).to eql value
       end
     end
 
-    describe 'option is a proc' do
-      let(:options) { { bar: -> { value } } }
+    describe 'option is a lambda' do
+      let(:options) { { host: -> { value } } }
       specify do
-        expect(subject.build(key, options)).to eql value
         expect(subject.build(key, options, request)).to eql value
       end
     end
+
+    describe 'option is a proc' do
+      let(:options) { { host: proc { |request| request.host =~ /^example/ ? '/api-example' : '/api' } } }
+      specify do
+        expect(subject.build(key, options, request)).to eql '/api-example'
+      end
+    end
   end
 end

data/spec/lib/path_string_spec.rb

@@ -8,29 +8,83 @@ describe GrapeSwagger::DocMethods::PathString do
 
   describe 'operation_id_object' do
     describe 'version' do
-      describe 'defaults: not given, false' do
+      describe 'defaults: given, true' do
+        let(:options) { { add_version: true } }
+        let(:route) { Struct.new(:version, :path).new('v1') }
+
+        specify 'The returned path includes version' do
+          route.path = '/{version}/thing(.json)'
+          expect(subject.build(route, options)).to eql ['Thing', '/v1/thing']
+          route.path = '/{version}/thing/foo(.json)'
+          expect(subject.build(route, options)).to eql ['Foo', '/v1/thing/foo']
+          route.path = '/{version}/thing(.:format)'
+          expect(subject.build(route, options)).to eql ['Thing', '/v1/thing']
+          route.path = '/{version}/thing/foo(.:format)'
+          expect(subject.build(route, options)).to eql ['Foo', '/v1/thing/foo']
+          route.path = '/{version}/thing/:id'
+          expect(subject.build(route, options)).to eql ['Thing', '/v1/thing/{id}']
+          route.path = '/{version}/thing/foo/:id'
+          expect(subject.build(route, options)).to eql ['Foo', '/v1/thing/foo/{id}']
+        end
+      end
+
+      describe 'defaults: not given, both false' do
         let(:options) { { add_version: false } }
+        let(:route) { Struct.new(:version, :path).new }
 
-        specify do
-          expect(subject.build('/thing(.json)', options)).to eql ['Thing', '/thing']
-          expect(subject.build('/thing/foo(.json)', options)).to eql ['Foo', '/thing/foo']
-          expect(subject.build('/thing(.:format)', options)).to eql ['Thing', '/thing']
-          expect(subject.build('/thing/foo(.:format)', options)).to eql ['Foo', '/thing/foo']
-          expect(subject.build('/thing/:id', options)).to eql ['Thing', '/thing/{id}']
-          expect(subject.build('/thing/foo/:id', options)).to eql ['Foo', '/thing/foo/{id}']
+        specify 'The returned path does not include version' do
+          route.path = '/{version}/thing(.json)'
+          expect(subject.build(route, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.json)'
+          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing(.:format)'
+          expect(subject.build(route, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.:format)'
+          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing/:id'
+          expect(subject.build(route, options)).to eql ['Thing', '/thing/{id}']
+          route.path = '/{version}/thing/foo/:id'
+          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo/{id}']
         end
       end
 
-      describe 'defaults: given, true' do
-        let(:options) { { version: 'v1', add_version: true } }
-
-        specify do
-          expect(subject.build('/{version}/thing(.json)', options)).to eql ['Thing', '/v1/thing']
-          expect(subject.build('/{version}/thing/foo(.json)', options)).to eql ['Foo', '/v1/thing/foo']
-          expect(subject.build('/{version}/thing(.:format)', options)).to eql ['Thing', '/v1/thing']
-          expect(subject.build('/{version}/thing/foo(.:format)', options)).to eql ['Foo', '/v1/thing/foo']
-          expect(subject.build('/{version}/thing/:id', options)).to eql ['Thing', '/v1/thing/{id}']
-          expect(subject.build('/{version}/thing/foo/:id', options)).to eql ['Foo', '/v1/thing/foo/{id}']
+      describe 'defaults: add_version false' do
+        let(:options) { { add_version: false } }
+        let(:route) { Struct.new(:version, :path).new('v1') }
+
+        specify 'The returned path does not include version' do
+          route.path = '/{version}/thing(.json)'
+          expect(subject.build(route, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.json)'
+          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing(.:format)'
+          expect(subject.build(route, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.:format)'
+          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing/:id'
+          expect(subject.build(route, options)).to eql ['Thing', '/thing/{id}']
+          route.path = '/{version}/thing/foo/:id'
+          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo/{id}']
+        end
+      end
+
+      describe 'defaults: root_version nil' do
+        let(:options) { { add_version: true } }
+        let(:route) { Struct.new(:version, :path).new }
+
+        specify 'The returned path does not include version' do
+          route.path = '/{version}/thing(.json)'
+          expect(subject.build(route, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.json)'
+          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing(.:format)'
+          expect(subject.build(route, options)).to eql ['Thing', '/thing']
+          route.path = '/{version}/thing/foo(.:format)'
+          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo']
+          route.path = '/{version}/thing/:id'
+          expect(subject.build(route, options)).to eql ['Thing', '/thing/{id}']
+          route.path = '/{version}/thing/foo/:id'
+          expect(subject.build(route, options)).to eql ['Foo', '/thing/foo/{id}']
         end
       end
     end