introspective_grape 0.0.4 → 0.1.9

data/lib/introspective_grape/api.rb

@@ -1,10 +1,15 @@
 require 'action_controller'
+require 'grape-kaminari'
 
 module IntrospectiveGrape
-  # Allow files to be uploaded through ActionController:
-  ActionController::Parameters::PERMITTED_SCALAR_TYPES.push Rack::Multipart::UploadedFile, ActionController::Parameters
-
   class API < Grape::API
+    extend IntrospectiveGrape::Helpers
+    extend IntrospectiveGrape::Filters
+    extend IntrospectiveGrape::Traversal
+
+    # Allow files to be uploaded through ActionController:
+    ActionController::Parameters::PERMITTED_SCALAR_TYPES.push Rack::Multipart::UploadedFile, ActionController::Parameters
+
     # Generate uniform RESTful APIs for an ActiveRecord Model:
     #
     # class <Some API Controller> < IntrospectiveGrape::API
@@ -33,33 +38,21 @@ module IntrospectiveGrape
     #
 
     class << self
-      PLURAL_REFLECTIONS = [ ActiveRecord::Reflection::HasManyReflection, ActiveRecord::Reflection::HasManyReflection]
-
-      Pg2Ruby = {
-        # mapping of activerecord/postgres 'type's to ruby data classes, where they differ
-        datetime: DateTime
-      }
-
-      def exclude_actions(model, *args)
-        @exclude_actions ||= {}
-        @@api_actions ||= [:index,:show,:create,:update,:destroy,nil]
-        raise "#{model.name} defines invalid exclude_actions: #{args-@@api_actions}" if (args.flatten-@@api_actions).present?
-        @exclude_actions[model.name] = args.present? ? args.flatten : @exclude_actions[model.name] || []
-      end
-
-      def default_includes(model, *args)
-        @default_includes ||= {}
-        @default_includes[model.name] = args.present? ? args.flatten : @default_includes[model.name] || []
-      end
+      PLURAL_REFLECTIONS = [ ActiveRecord::Reflection::HasManyReflection, ActiveRecord::Reflection::HasManyReflection].freeze
+      # mapping of activerecord/postgres 'type's to ruby data classes, where they differ
+      Pg2Ruby = { datetime: DateTime }.freeze
 
       def inherited(child)
         super(child)
         child.before do
+          # Ensure that a user is logged in.
+          self.send(IntrospectiveGrape::API.authentication_method(self))
+        end
+
+        child.after_validation do
           # Convert incoming camel case params to snake case: grape will totally blow this
-          # if the params hash is not a Hashie::Mash, so make it one of those:
-          @params = Hashie::Mash.new(snake_keys(params))
-          # ensure that a user is logged in
-          authorize!
+          # if the params hash does not come back as a Hashie::Mash.
+          @params = (params||Hashie::Mash.new).with_snake_keys if IntrospectiveGrape.config.camelize_parameters
         end
       end
 
@@ -93,8 +86,7 @@ module IntrospectiveGrape
         # As routes are nested keep track of the routes, we are preventing siblings from 
         # appending to the routes array here:
         routes = build_routes(routes, model)
-
-        define_routes(routes,whitelist)
+        define_routes(routes, whitelist)
 
         resource routes.first.name.pluralize do
           # yield to append additional routes under the root namespace
@@ -102,13 +94,12 @@ module IntrospectiveGrape
         end
       end
 
-      def define_routes(routes, whitelist)
-        define_endpoint(routes, whitelist)
-
+      def define_routes(routes, api_params)
+        define_endpoints(routes, api_params)
         # recursively define endpoints
         model = routes.last.model || return
 
-        whitelist.select{|a| a.kind_of?(Hash) }.each do |nested|
+        api_params.select{|a| a.kind_of?(Hash) }.each do |nested|
           # Recursively add RESTful nested routes for every nested model:
           nested.each do |r,fields|
             # Look at model.reflections to find the association's class name:
@@ -120,162 +111,179 @@ module IntrospectiveGrape
             end
 
             next_routes = build_routes(routes, relation, reflection_name)
-
             define_routes(next_routes, fields)
           end
         end
       end
 
-      def build_routes(routes, model, reflection_name=nil)
-        routes = routes.clone
-        # routes: the existing routes array passed from the parent
-        # model:  the model being manipulated in this leaf
-        # reflection_name: the association name from the original strong_params declaration
-        # 
-        # Constructs an array representation of the route's models and their associations,
-        # a /root/:rootId/branch/:branchId/leaf/:leafId path would have flat array like
-        # [root,branch,leaf] representing the path structure and its models, used to
-        # manipulate ActiveRecord relationships and params hashes and so on.
-        parent_model = routes.last.try(:model)
-        return routes if model == parent_model
 
-        name       = reflection_name || model.name.underscore
-        reflection = parent_model && parent_model.reflections[reflection_name]
-        many       = parent_model && PLURAL_REFLECTIONS.include?( reflection.class ) ? true : false
-        routes.push OpenStruct.new(name: name, param: "#{name}_attributes", model: model, many?: many, key: "#{name.singularize}_id".to_sym, swaggerKey: "#{name.singularize.camelize(:lower)}Id", reflection: reflection)
-      end
-
-      def define_endpoint(routes,api_params)
-        # Inside the Grape DSL "self" will derefernece to its Endpoint classes,
-        # so save a reference to our API class:
-        klass     = self
+      def define_endpoints(routes,api_params)
         # De-reference these as local variables from their class scope, or when we make
         # calls to the API they will be whatever they were last set to by the recursive
         # calls to "nest_routes".
         routes     = routes.clone
         api_params = api_params.clone
 
-        root      = routes.first
         model     = routes.last.model || return
-        name      = routes.last.name.singularize
+
         # We define the param keys for ID fields in camelcase for swagger's URL substitution,
         # they'll come back in snake case in the params hash, the API as a whole is agnostic:
-        swaggerKey = routes.last.swaggerKey
-
-        namespace = routes[0..-2].map{|p| "#{p.name.pluralize}/:#{p.swaggerKey}/" }.join + name.pluralize
+        namespace = routes[0..-2].map{|p| "#{p.name.pluralize}/:#{p.swaggerKey}/" }.join + routes.last.name.pluralize
 
         resource namespace do
+          convert_nested_params_hash(self, routes)
+          define_restful_api(self, routes, model, api_params)
+        end
+      end
 
-          after_validation do
-            # After Grape validates its parameters:
-            # 1) Find the root model instance for the API if its passed (implicitly either
-            #    an update/destroy on the root node or it's a nested route
-            # 2) For nested endpoints convert the params hash into Rails-compliant nested
-            #    attributes, to be passed to the root instance for update. This keeps
-            #    behavior consistent between bulk and single record updates.
-            if params[root.key]
-              default_includes = routes.size > 1 ? [] : root.model.default_includes
-              @model = root.model.includes( default_includes ).find(params[root.key])
-            end
-
-            if routes.size > 1
-              nested_attributes = klass.build_nested_attributes(routes[1..-1], params.except(root.key,:api_key) )
-
-              @params.merge!( nested_attributes ) if nested_attributes.kind_of?(Hash)
-            end
-
-          end
-
-          unless model.exclude_actions.include?(:index)
-            desc "list #{name.pluralize}" do
-              detail "returns list of all #{name.pluralize}"
-            end
-            get '/' do
-              # Invoke the policy for the action, defined in the policy classes for the model:
-              authorize root.model.new, :index?
-
-              # Nested route indexes need to be scoped by the API's top level policy class:
-              records = policy_scope( root.model.includes(klass.default_includes(root.model)) )
+      def define_restful_api(dsl, routes, model, api_params) 
+        # declare index, show, update, create, and destroy methods:
+        API_ACTIONS.each do |action|
+          send("define_#{action}", dsl, routes, model, api_params) unless exclude_actions(model).include?(action)
+        end
+      end
 
-              records = records.map{|r| klass.find_leaves( routes, r, params ) }.flatten.compact.uniq
+      def define_index(dsl, routes, model, api_params)
+        include Grape::Kaminari
+        root  = routes.first
+        klass = routes.first.klass
+        name  = routes.last.name.pluralize
+        simple_filters(klass, model, api_params)
 
-              present records, with: "#{klass}::#{model}Entity".constantize
-            end
-          end
+        dsl.desc "list #{name}" do
+          detail "returns list of all #{name}"
+        end
+        dsl.params do
+          klass.declare_filter_params(self, klass, model, api_params)
+        end
+        if klass.pagination
+          paginate per_page: klass.pagination[:per_page]||25, max_per_page: klass.pagination[:max_per_page], offset: klass.pagination[:offset]||0
+        end
+        dsl.get '/' do
+          # Invoke the policy for the action, defined in the policy classes for the model:
+          authorize root.model.new, :index?
+
+          # Nested route indexes need to be scoped by the API's top level policy class:
+          records = policy_scope( root.model.includes(klass.default_includes(root.model)) )
+
+          records = klass.apply_filter_params(klass, model, api_params, params, records)
+          records = records.where( JSON.parse(params[:query]) ) if params[:query].present?
+          records = records.map{|r| klass.find_leaves( routes, r, params ) }.flatten.compact.uniq
+          # paginate the records using Kaminari
+          records = paginate(Kaminari.paginate_array(records)) if klass.pagination
+          present records, with: "#{klass}::#{model}Entity".constantize
+        end
+      end
 
+      def define_show(dsl, routes, model, _api_params)
+        name = routes.last.name.singularize
+        klass = routes.first.klass
+        dsl.desc "retrieve a #{name}" do
+          detail "returns details on a #{name}"
+        end
+        dsl.get ":#{routes.last.swaggerKey}" do
+          authorize @model, :show?
+          present klass.find_leaf(routes, @model, params), with: "#{klass}::#{model}Entity".constantize
+        end
+      end
 
-          unless model.exclude_actions.include?(:show)
-            desc "retrieve a #{name}" do
-              detail "returns details on a #{name}"
-            end
-            get ":#{swaggerKey}" do
-              authorize @model, :show?
-              present klass.find_leaf(routes, @model, params), with: "#{klass}::#{model}Entity".constantize
-            end
+      def define_create(dsl, routes, model, api_params)
+        name  = routes.last.name.singularize
+        klass = routes.first.klass
+        root  = routes.first
+        dsl.desc "create a #{name}" do
+          detail "creates a new #{name} record"
+        end
+        dsl.params do
+          klass.generate_params(self, klass, :create, model, api_params)
+        end
+        dsl.post do
+          if @model
+            @model.update_attributes( safe_params(params).permit(klass.whitelist) )
+          else 
+            @model = root.model.new( safe_params(params).permit(klass.whitelist) ) 
           end
+          authorize @model, :create?
+          @model.save!
+          present klass.find_leaves(routes, @model.reload, params), with: "#{klass}::#{model}Entity".constantize
+        end
+      end
 
+      def define_update(dsl, routes, model, api_params)
+        klass = routes.first.klass
+        name = routes.last.name.singularize
+        dsl.desc "update a #{name}" do
+          detail "updates the details of a #{name}"
+        end
+        dsl.params do
+          klass.generate_params(self, klass, :update, model, api_params)
+        end
+        dsl.put ":#{routes.last.swaggerKey}" do
+          authorize @model, :update?
 
-          unless model.exclude_actions.include?(:create)
-            desc "create a #{name}" do
-              detail "creates a new #{name} record"
-            end
-            params do
-              klass.generate_params(self, klass, :create, model, api_params)
-            end
-            post do
-              if (@model) 
-                @model.update_attributes( safe_params(params).permit(klass.whitelist) )
-              else 
-                @model = root.model.new( safe_params(params).permit(klass.whitelist) ) 
-              end
-              authorize @model, :create?
-              @model.save!
-              present klass.find_leaves(routes, @model, params), with: "#{klass}::#{model}Entity".constantize
-            end
-          end
-
+          @model.update_attributes!( safe_params(params).permit(klass.whitelist) )
 
-          unless model.exclude_actions.include?(:update)
-            desc "update a #{name}" do
-              detail "updates the details of a #{name}"
-            end
-            params do
-              klass.generate_params(self, klass, :update, model, api_params)
-            end
-            put ":#{swaggerKey}" do
-              authorize @model, :update?
+          present klass.find_leaf(routes, @model.reload, params), with: "#{klass}::#{model}Entity".constantize
+        end
+      end
 
-              @model.update_attributes!( safe_params(params).permit(klass.whitelist) )
+      def define_destroy(dsl, routes, _model, _api_params)
+        klass = routes.first.klass
+        name = routes.last.name.singularize
+        dsl.desc "destroy a #{name}" do
+          detail "destroys the details of a #{name}"
+        end
+        dsl.delete ":#{routes.last.swaggerKey}" do
+          authorize @model, :destroy?
+          present status: (klass.find_leaf(routes, @model, params).destroy ? true : false)
+        end
+      end
 
-              present klass.find_leaf(routes, @model, params), with: "#{klass}::#{model}Entity".constantize
-            end
+      def convert_nested_params_hash(dsl, routes)
+        root  = routes.first
+        klass = root.klass
+        dsl.after_validation do
+          # After Grape validates its parameters:
+          # 1) Find the root model instance for the API if its passed (implicitly either
+          #    an update/destroy on the root node or it's a nested route
+          # 2) For nested endpoints convert the params hash into Rails-compliant nested
+          #    attributes, to be passed to the root instance for update. This keeps
+          #    behavior consistent between bulk and single record updates.
+          if params[root.key]
+            default_includes = routes.size > 1 ? [] : klass.default_includes(root.model)
+            @model = root.model.includes( default_includes ).find(params[root.key])
           end
 
-
-          unless model.exclude_actions.include?(:destroy)
-            desc "destroy a #{name}" do
-              detail "destroys the details of a #{name}"
-            end
-            delete ":#{swaggerKey}" do
-              authorize @model, :destroy?
-              present status: (klass.find_leaf(routes, @model, params).destroy ? true : false)
-            end
+          if routes.size > 1
+            nested_attributes = klass.build_nested_attributes(routes[1..-1], params.except(root.key,:api_key) )
+            @params.merge!( nested_attributes ) if nested_attributes.kind_of?(Hash)
           end
-
         end
       end
 
 
-      def whitelist(whitelist=nil)
-        return @whitelist if !whitelist
-        @whitelist = whitelist
-      end
+      def build_routes(routes, model, reflection_name=nil)
+        routes = routes.clone
+        # routes: the existing routes array passed from the parent
+        # model:  the model being manipulated in this leaf
+        # reflection_name: the association name from the original strong_params declaration
+        # 
+        # Constructs an array representation of the route's models and their associations,
+        # a /root/:rootId/branch/:branchId/leaf/:leafId path would have flat array like
+        # [root,branch,leaf] representing the path structure and its models, used to
+        # manipulate ActiveRecord relationships and params hashes and so on.
+        parent_model = routes.last.try(:model)
+        return routes if model == parent_model
+
+        name       = reflection_name || model.name.underscore
+        reflection = parent_model.try(:reflections).try(:fetch,reflection_name)
+        many       = parent_model && PLURAL_REFLECTIONS.include?( reflection.class ) ? true : false
+        swaggerKey = IntrospectiveGrape.config.camelize_parameters ? "#{name.singularize.camelize(:lower)}Id" : "#{name.singularize}_id"
 
-      def skip_presence_validations(fields=nil)
-        return @skip_presence_fields||[] if !fields
-        @skip_presence_fields = [fields].flatten
+        routes.push OpenStruct.new(klass: self, name: name, param: "#{name}_attributes", model: model, many?: many, key: "#{name.singularize}_id".to_sym, swaggerKey: swaggerKey, reflection: reflection)
       end
 
+
       def build_nested_attributes(routes,hash) 
         # Recursively re-express the flat attributes hash from nested routes as nested
         # attributes that can be used to perform an update on the root model.
@@ -298,47 +306,6 @@ module IntrospectiveGrape
       end
 
 
-      def find_leaves(routes, record, params)
-        # Traverse down our route and find the leaf's siblings from its parent, e.g.
-        # project/#/teams/#/team_users ~> project.find.teams.find.team_users.
-        # (the traversal of the intermediate nodes occurs in find_leaf())
-        return record if routes.size < 2 # the leaf is the root
-        if record = find_leaf(routes, record, params)
-          assoc = routes.last
-          if assoc.many? && leaves = record.send( assoc.reflection.name ).includes( default_includes(assoc.model) )
-            if (leaves.map(&:class) - [routes.last.model]).size > 0 
-              raise ActiveRecord::RecordNotFound.new("Records contain the wrong models, they should all be #{routes.last.model.name}, found #{records.map(&:class).map(&:name).join(',')}")
-            end
-
-            leaves
-          else 
-            # has_one associations don't return a CollectionProxy and so don't support 
-            # eager loading.
-            record.send( assoc.reflection.name )
-          end
-        end
-      end
-
-      def find_leaf(routes, record, params)
-        return record unless routes.size > 1
-        # For deeply nested routes we need to search from the root of the API to the leaf
-        # of its nested associations in order to guarantee the validity of the relationship,
-        # the authorization on the parent model, and the sanity of passed parameters. 
-        routes[1..-1].each_with_index do |r|
-          if record && params[r.key]
-            if ref = r.reflection 
-              record = record.send(ref.name).where( id: params[r.key] ).first
-            end
-          end
-        end
-
-        if params[routes.last.key] && record.class != routes.last.model
-          raise ActiveRecord::RecordNotFound.new("No #{routes.last.model.name} with ID '#{params[routes.last.key]}'")
-        end
-
-        record
-      end
-
 
       def generate_params(dsl, klass, action, model, fields)
         # We'll be doing a recursive walk (to handle nested attributes) down the
@@ -355,17 +322,15 @@ module IntrospectiveGrape
         #         infer Grape's parameters
 
         (fields-[:id]).each do |field|
-          if ( field.kind_of?(Hash) )
+          if field.kind_of?(Hash)
             generate_nested_params(dsl,klass,action,model,field)
+          elsif (action==:create && klass.param_required?(model,field) )
+            # All params are optional on an update, only require them during creation.
+            # Updating a record with new child models will have to rely on ActiveRecord
+            # validations:
+            dsl.requires field, type: klass.param_type(model,field)
           else
-            if (action==:create && klass.param_required?(model,field) )
-              # All params are optional on an update, only require them during creation.
-              # Updating a record with new child models will have to rely on ActiveRecord
-              # validations:
-              dsl.requires field, type: klass.param_type(model,field)
-            else
-              dsl.optional field, type: klass.param_type(model,field)
-            end
+            dsl.optional field, type: klass.param_type(model,field)
           end
         end
       end
@@ -374,32 +339,29 @@ module IntrospectiveGrape
         fields.each do |r,v|
           # Look at model.reflections to find the association's class name:
           reflection = r.to_s.sub(/_attributes$/,'') # the reflection name
-          relation = begin
-            model.reflections[reflection].class_name.constantize # its class
-          rescue
-            model
-          end
+          relation = begin model.reflections[reflection].class_name.constantize rescue model end
 
           if is_file_attachment?(model,r)
             # Handle Carrierwave file upload fields
-            if s = [:filename, :type, :name, :tempfile, :head]-v && s.present?
+            s = [:filename, :type, :name, :tempfile, :head]-v
+            if s.present?
               Rails.logger.warn "Missing required file upload parameters #{s} for uploader field #{r}" 
             end
           elsif PLURAL_REFLECTIONS.include?( model.reflections[reflection].class )
             # In case you need a refresher on how these work:
             # http://api.rubyonrails.org/classes/ActiveRecord/NestedAttributes/ClassMethods.html
-            dsl.optional r, type: Array do |dsl|
-              klass.generate_params(dsl,klass,action,relation,v)
-              klass.add_destroy_param(dsl,model,reflection) unless action==:create
+            dsl.optional r, type: Array do |dl|
+              klass.generate_params(dl,klass,action,relation,v)
+              klass.add_destroy_param(dl,model,reflection) unless action==:create
             end
           else
             # TODO: handle any remaining correctly. Presently defaults to a Hash
             # http://www.rubydoc.info/github/rails/rails/ActiveRecord/Reflection
             # ThroughReflection, HasOneReflection,
             # HasAndBelongsToManyReflection, BelongsToReflection
-            dsl.optional r, type: Hash do |dsl|
-              klass.generate_params(dsl,klass,action,relation,v)
-              klass.add_destroy_param(dsl,model,reflection) unless action==:create
+            dsl.optional r, type: Hash do |dl|
+              klass.generate_params(dl,klass,action,relation,v)
+              klass.add_destroy_param(dl,model,reflection) unless action==:create
             end
           end
         end
@@ -407,8 +369,8 @@ module IntrospectiveGrape
 
       def is_file_attachment?(model,field)
         model.try(:uploaders) && model.uploaders[field.to_sym] || # carrierwave
-        model.try(:paperclip_definitions) && model.paperclip_definitions[field.to_sym] || # paperclip
-        model.send(:new).try(field).kind_of?(Paperclip::Attachment)
+          (model.try(:attachment_definitions) && model.attachment_definitions[field.to_sym]) ||
+          defined?(Paperclip::Attachment) && model.send(:new).try(field).kind_of?(Paperclip::Attachment)
       end
 
       def param_type(model,f)
@@ -416,8 +378,8 @@ module IntrospectiveGrape
         f       = f.to_s
         db_type = (model.try(:columns_hash)||{})[f].try(:type)
 
-        # Look for an override class from the model, check Pg2Ruby, use the database type,
-        # or fail over to a String:
+        # Check if it's a file attachment, look for an override class from the model,
+        # check Pg2Ruby, use the database type, or fail over to a String:
         ( is_file_attachment?(model,f) && Rack::Multipart::UploadedFile ) || 
           (model.try(:attribute_param_types)||{})[f]                      || 
           Pg2Ruby[db_type]                                                ||
@@ -441,5 +403,4 @@ module IntrospectiveGrape
 
     end
   end
-
 end

data/lib/introspective_grape/camel_snake.rb

@@ -1,71 +1,40 @@
 require 'grape-swagger'
 require 'active_support' #/core_ext/module/aliasing'
-module IntrospectiveGrape::CamelSnake
-  def snake_keys(data)
-    if data.kind_of? Array
-      data.map { |v| snake_keys(v) }
-    elsif data.kind_of? Hash
-      Hash[data.map {|k, v| [k.to_s.underscore, snake_keys(v)] }]
-    else
-      data
-    end
-  end
-
-  def camel_keys(data)
-    if data.kind_of? Array
-      data.map { |v| camel_keys(v) }
-    elsif data.kind_of?(Hash)
-      Hash[data.map {|k, v| [k.to_s.camelize(:lower), camel_keys(v)] }]
-    else
-      data
-    end
-  end
-end
+require 'camel_snake_keys'
 
-# Duck type Grape's built in JSON formatter to convert all snake case hash keys
-# to camel case.
-module Grape
-  module Formatter
-    module Json
+if IntrospectiveGrape.config.camelize_parameters 
+  # Camelize the parameters in the swagger documentation.
+  if Gem::Version.new( GrapeSwagger::VERSION ) <= Gem::Version.new('0.11.0')
+    Grape::API.class_eval do 
       class << self
-        include IntrospectiveGrape::CamelSnake
-        def call(object, env)
-          if object.respond_to?(:to_json)
-            camel_keys(JSON.parse(object.to_json)).to_json
-         else
-            camel_keys(MultiJson.dump(object)).to_json
-          end
-        end
-      end
-    end
-  end
-end
-
-# Camelize the parameters in the swagger documentation.
-module Grape
-  class API
-    class << self
-      private
-      def create_documentation_class_with_camelized
-        doc = create_documentation_class_without_camelized
-        doc.class_eval do
-          class << self
-            def parse_params_with_camelized(params, path, method, options = {})
-              parsed_params = parse_params_without_camelized(params, path, method)
-              parsed_params.each_with_index do |param|
-                param[:name] = param[:name]
-                               .camelize(:lower)
-                               .gsub(/\[Destroy\]/,'[_destroy]')
+        private
+        def create_documentation_class_with_camelized
+          doc = create_documentation_class_without_camelized
+          doc.class_eval do
+            class << self
+              def parse_params_with_camelized(params, path, method, _options = {})
+                parsed_params = parse_params_without_camelized(params, path, method)
+                parsed_params.each_with_index do |param|
+                  param[:name] = param[:name]
+                                 .camelize(:lower)
+                                 .gsub(/Destroy/,'_destroy')
+                end
+                parsed_params
               end
-              parsed_params
-            end
 
-            alias_method_chain :parse_params, :camelized
+              alias_method_chain :parse_params, :camelized
+            end
           end
+          doc
         end
-        doc
+        alias_method_chain :create_documentation_class, :camelized
       end
-      alias_method_chain :create_documentation_class, :camelized
     end
+  else Gem::Version.new( GrapeSwagger::VERSION ) > Gem::Version.new('0.11.0')
+    # Grape::Swagger 0.20.xx is not yet compatible with Grape >0.14 and will alter
+    # the way it parses params, so will not be compatible with introspective_grape,
+    # and produces swagger docs for SwaggerUI 2.1.4 that don't appear to be
+    # backwards compatible swagger.js 2.0.41, so this is pending.
   end
+
 end