introspective_grape 0.6.1 → 0.7.0

data/lib/introspective_grape/camel_snake.rb

@@ -11,7 +11,7 @@ if IntrospectiveGrape.config.camelize_parameters
         parsed_params.each do |param|
           param[:name] = param[:name]
                          .camelize(:lower)
-                         .gsub(/Destroy/, '_destroy')
+                         .gsub('Destroy', '_destroy')
         end
         super(params, path, method, _options = {})
       end
@@ -34,8 +34,8 @@ if IntrospectiveGrape.config.camelize_parameters
   else
     module CallWithCamelized
       def call(*args)
-        param = super(*args)
-        param[:name] = param[:name].camelize(:lower).gsub(/Destroy/, '_destroy')
+        param = super
+        param[:name] = param[:name].camelize(:lower).gsub('Destroy', '_destroy')
         param
       end
     end

data/lib/introspective_grape/create_helpers.rb

@@ -1,25 +1,25 @@
-module IntrospectiveGrape
-  module CreateHelpers
-    def add_new_records_to_root_record(dsl, routes, params, model)
-      dsl.send(:authorize, model, :create?)
-      ActiveRecord::Base.transaction do
-        old = find_leaves(routes, model, params)
-        model.update( dsl.send(:safe_params, params).permit(whitelist) )
-        new = find_leaves(routes, model, params)
-        old.respond_to?(:size) ? new - old : new
-      end
-    end
-
-    def create_new_record(dsl, routes, params)
-      model = routes.first.model.new( dsl.send(:safe_params, params).permit(whitelist) )
-      dsl.send(:authorize, model, :create?)
-      model.save!
-
-      # reload the model with eager loading
-      default_includes = routes.first.klass.default_includes(routes.first.model)
-      model = model.class.includes(default_includes).find(model.id) if model.persisted?
-
-      find_leaves(routes, model, params)
-    end
-  end
-end
+module IntrospectiveGrape
+  module CreateHelpers
+    def add_new_records_to_root_record(dsl, routes, params, model)
+      dsl.send(:authorize, model, :create?)
+      ActiveRecord::Base.transaction do
+        old = find_leaves(routes, model, params)
+        model.update( dsl.send(:safe_params, params).permit(whitelist) )
+        new = find_leaves(routes, model, params)
+        old.respond_to?(:size) ? new - old : new
+      end
+    end
+
+    def create_new_record(dsl, routes, params)
+      model = routes.first.model.new( dsl.send(:safe_params, params).permit(whitelist) )
+      dsl.send(:authorize, model, :create?)
+      model.save!
+
+      # reload the model with eager loading
+      default_includes = routes.first.klass.default_includes(routes.first.model)
+      model = model.class.includes(default_includes).find(model.id) if model.persisted?
+
+      find_leaves(routes, model, params)
+    end
+  end
+end

data/lib/introspective_grape/filters.rb

@@ -62,7 +62,7 @@ module IntrospectiveGrape
       if timestamp_filter(klass, model, field)
         dsl.optional field, type: klass.param_type(model, field), description: "Constrain #{field} by #{humanize_date_range(field)} date."
       elsif identifier_filter?(model, field)
-        dsl.optional field, type: Array[String], coerce_with: ->(val) { val.split(',') }, description: 'Filter by a comma separated list of unique identifiers.'
+        dsl.optional field, type: [String], coerce_with: ->(val) { val.split(',') }, description: 'Filter by a comma separated list of unique identifiers.'
       else
         dsl.optional field, type: klass.param_type(model, field), description: "Filter on #{field} by value."
       end
@@ -82,7 +82,9 @@ module IntrospectiveGrape
 
     def filter_doc
       <<-STR
-        JSON of conditions for query.  If you're familiar with ActiveRecord's query conventions you can build more complex filters, i.e. against included child associations, e.g.: {\"&lt;association_name&gt;_&lt;parent&gt;\":{\"field\":\"value\"}}
+  JSON of conditions for query.
+
+  If you're familiar with ActiveRecord's query conventions you can build more complex filters, i.e. against included child associations, e.g.: {"&lt;association_name&gt;_&lt;parent&gt;":{"field":"value"}}
       STR
     end
 
@@ -106,7 +108,7 @@ module IntrospectiveGrape
         records = apply_simple_filter(klass, model, params, records, field)
       end
 
-      klass.custom_filters.each do |filter, _details|
+      klass.custom_filters.each_key do |filter|
         records = records.send(filter, params[filter])
       end
 

data/lib/introspective_grape/route.rb

@@ -0,0 +1,11 @@
+class Route
+  attr_accessor(*%i[klass name param model many key swagger_key reflection])
+
+  def initialize(attrs = {})
+    attrs.each { |key, value| instance_variable_set("@#{key}", value) }
+  end
+
+  def many?
+    many ? true : false
+  end
+end

data/lib/introspective_grape/traversal.rb

@@ -1,56 +1,56 @@
-module IntrospectiveGrape
-  module Traversal
-    # For deeply nested endpoints we want to present the record being affected, these
-    # methods traverse down from the parent instance to the child model associations
-    # of the deeply nested route.
-
-    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
-
-      record = find_leaf(routes, record, params) || return
-
-      assoc  = routes.last
-      if assoc.many?
-        leaves = record.send( assoc.reflection.name ).includes( default_includes(assoc.model) )
-        verify_records_found(leaves, routes)
-        leaves
-      else
-        # has_one associations don't return a CollectionProxy and so don't support
-        # eager loading.
-        record.send( assoc.reflection.name )
-      end
-    end
-
-    def verify_records_found(leaves, routes)
-      return if (leaves.map(&:class) - [routes.last.model]).empty?
-
-      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
-
-    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..].each do |r|
-        if record && params[r.key]
-          ref    = r.reflection
-          record = record.send(ref.name).where( id: params[r.key] ).first if ref
-        end
-      end
-
-      verify_record_found(routes, params, record)
-      record
-    end
-
-    def verify_record_found(routes, params, record)
-      return unless 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
-  end
-end
+module IntrospectiveGrape
+  module Traversal
+    # For deeply nested endpoints we want to present the record being affected, these
+    # methods traverse down from the parent instance to the child model associations
+    # of the deeply nested route.
+
+    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
+
+      record = find_leaf(routes, record, params) || return
+
+      assoc  = routes.last
+      if assoc.many?
+        leaves = record.send( assoc.reflection.name ).includes( default_includes(assoc.model) )
+        verify_records_found(leaves, routes)
+        leaves
+      else
+        # has_one associations don't return a CollectionProxy and so don't support
+        # eager loading.
+        record.send( assoc.reflection.name )
+      end
+    end
+
+    def verify_records_found(leaves, routes)
+      return if (leaves.map(&:class) - [routes.last.model]).empty?
+
+      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
+
+    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..].each do |r|
+        if record && params[r.key]
+          ref    = r.reflection
+          record = record.send(ref.name).where( id: params[r.key] ).first if ref
+        end
+      end
+
+      verify_record_found(routes, params, record)
+      record
+    end
+
+    def verify_record_found(routes, params, record)
+      return unless 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
+  end
+end

data/lib/introspective_grape/validators.rb

@@ -1,36 +1,37 @@
-require 'grape/validations'
-module Grape
-  module Validators
-    # Validations::Base becomes Validators::Base somewhere between 1.6.0 and 1.6.2
-    validation_class = defined?(Grape::Validations::Base) ? Grape::Validations::Base : Grape::Validations::Validators::Base
-    class Json < validation_class
-      def validate_param!(field, params)
-        begin
-          JSON.parse( params[field] )
-        rescue StandardError
-          raise Grape::Exceptions::Validation.new params: [@scope.full_name(field)], message: 'must be valid JSON!'
-        end
-      end
-    end
-
-    class JsonArray < validation_class
-      def validate_param!(field, params)
-        begin
-          raise unless JSON.parse( params[field] ).is_a? Array
-        rescue StandardError
-          raise Grape::Exceptions::Validation.new params: [@scope.full_name(field)], message: 'must be a valid JSON array!'
-        end
-      end
-    end
-
-    class JsonHash < validation_class
-      def validate_param!(field, params)
-        begin
-          raise unless JSON.parse( params[field] ).is_a? Hash
-        rescue StandardError
-          raise Grape::Exceptions::Validation.new params: [@scope.full_name(field)], message: 'must be a valid JSON hash!'
-        end
-      end
-    end
-  end
-end
+require 'grape/validations'
+module Grape
+  module Validators
+    # Validations::Base becomes Validators::Base somewhere between 1.6.0 and 1.6.2
+    validation_class = defined?(Grape::Validations::Validators::Base) ? Grape::Validations::Validators::Base : Grape::Validations::Base
+
+    class Json < validation_class
+      def validate_param!(field, params)
+        begin
+          JSON.parse( params[field] )
+        rescue StandardError
+          raise Grape::Exceptions::Validation.new params: [@scope.full_name(field)], message: 'must be valid JSON!'
+        end
+      end
+    end
+
+    class JsonArray < validation_class
+      def validate_param!(field, params)
+        begin
+          raise unless JSON.parse( params[field] ).is_a? Array
+        rescue StandardError
+          raise Grape::Exceptions::Validation.new params: [@scope.full_name(field)], message: 'must be a valid JSON array!'
+        end
+      end
+    end
+
+    class JsonHash < validation_class
+      def validate_param!(field, params)
+        begin
+          raise unless JSON.parse( params[field] ).is_a? Hash
+        rescue StandardError
+          raise Grape::Exceptions::Validation.new params: [@scope.full_name(field)], message: 'must be a valid JSON hash!'
+        end
+      end
+    end
+  end
+end

data/lib/introspective_grape/version.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
-
-module IntrospectiveGrape
-  VERSION = '0.6.1'
-end
+# frozen_string_literal: true
+
+module IntrospectiveGrape
+  VERSION = '0.7.0'
+end

data/lib/introspective_grape.rb

@@ -9,6 +9,7 @@ module IntrospectiveGrape
   autoload :Helpers,        'introspective_grape/helpers'
   autoload :SnakeParams,    'introspective_grape/snake_params'
   autoload :Traversal,      'introspective_grape/traversal'
+  autoload :Route,          'introspective_grape/route'
 
   module Formatter
     autoload :CamelJson, 'introspective_grape/formatter/camel_json'

data/spec/dummy/Gemfile

@@ -1,23 +1,24 @@
-source 'https://rubygems.org'
-gem 'rails' #, '5.2.6.2'
-
-gem 'byebug'
-gem 'listen'
-gem 'camel_snake_keys'
-
-gem 'devise'
-gem 'delayed_paperclip'
-gem 'kt-paperclip'
-
-gem 'grape'
-gem 'grape-entity'
-gem 'grape-kaminari'
-gem 'grape-swagger'
-gem 'grape-swagger-entity'
-gem 'introspective_grape', path: '~/Dropbox/contrib/introspective_grape'
-
-gem 'paperclip'
-gem 'pundit'
-
-gem 'rack-cors'
-gem 'sqlite3'
+source 'https://rubygems.org'
+gem 'rails' #, '5.2.6.2'
+
+gem 'byebug'
+gem 'listen'
+gem 'camel_snake_keys'
+
+gem 'devise'
+gem 'delayed_paperclip'
+gem 'kt-paperclip'
+
+gem 'grape'
+gem 'grape-entity'
+gem 'grape-kaminari'
+gem 'grape-swagger'
+gem 'grape-swagger-entity'
+gem 'introspective_grape', path: '~/Dropbox/contrib/introspective_grape'
+
+gem 'paperclip'
+gem 'pundit'
+
+gem 'rack-cors'
+gem 'sqlite3'
+gem 'validates_by_schema'

data/spec/dummy/app/api/{api_helpers.rb → authentication_helper.rb}

@@ -1,38 +1,38 @@
-module APIHelpers
-  def current_user
-    params[:api_key].present? && @user = User.find_by_authentication_token(params[:api_key])
-    # for testing in situ
-    @user = User.find_or_create_by(email: 'test@test.com', superuser: true, authentication_token: '1234567890', first_name: "First", last_name: "Last")
-    Current.user = @user
-  end
-
-  def authenticate!
-    unauthenticated! unless login_request? || current_user
-  end
-
-  def login_request?
-    self.method_name.start_with?('POST') && self.namespace == '/sessions'
-  end
-
-  # returns an 'unauthenticated' response
-  def unauthenticated!(error_type = nil)
-    respond_error!('unauthenticated', error_type, 401)
-  end
-
-  # returns a error response with given type, message_key and status
-  def respond_error!(type, message_key, status = 500, other = {})
-    e = {
-      type: type,
-      status: status
-    }
-    e['message_key'] = message_key if message_key
-    e.merge!(other)
-    error!({ error: e }, status)
-  end
-
-  private
-
-  def safe_params(params)
-    ActionController::Parameters.new(params)
-  end
-end
+module AuthenticationHelper
+  def current_user
+    params[:api_key].present? && @user = User.find_by_authentication_token(params[:api_key])
+    # for testing in situ
+    @user = User.find_or_create_by(email: 'test@test.com', superuser: true, authentication_token: '1234567890', first_name: "First", last_name: "Last")
+    Current.user = @user
+  end
+
+  def authenticate!
+    unauthenticated! unless login_request? || current_user
+  end
+
+  def login_request?
+    self.method_name.start_with?('POST') && self.namespace == '/sessions'
+  end
+
+  # returns an 'unauthenticated' response
+  def unauthenticated!(error_type = nil)
+    respond_error!('unauthenticated', error_type, 401)
+  end
+
+  # returns a error response with given type, message_key and status
+  def respond_error!(type, message_key, status = 500, other = {})
+    e = {
+      type: type,
+      status: status
+    }
+    e['message_key'] = message_key if message_key
+    e.merge!(other)
+    error!({ error: e }, status)
+  end
+
+  private
+
+  def safe_params(params)
+    ActionController::Parameters.new(params)
+  end
+end

data/spec/dummy/app/api/dummy/chat_api.rb

@@ -1,4 +1,4 @@
-class Dummy::ChatAPI < Grape::API
+class Dummy::ChatApi < Grape::API
   formatter :json, IntrospectiveGrape::Formatter::CamelJson
 
   before do

data/spec/dummy/app/api/dummy/company_api.rb

@@ -1,4 +1,4 @@
-class Dummy::CompanyAPI < IntrospectiveGrape::API
+class Dummy::CompanyApi < IntrospectiveGrape::API
   paginate
 
   restful Company, [:id, :name, :short_name, :gizmos, :widgets, :sprockets] do

data/spec/dummy/app/api/dummy/location_api.rb

@@ -1,4 +1,4 @@
-class Dummy::LocationAPI < IntrospectiveGrape::API
+class Dummy::LocationApi < IntrospectiveGrape::API
   exclude_actions Location, :none
   include_actions LocationBeacon, :index
   include_actions LocationGps, :index

data/spec/dummy/app/api/dummy/project_api.rb

@@ -1,4 +1,4 @@
-class Dummy::ProjectAPI < IntrospectiveGrape::API
+class Dummy::ProjectApi < IntrospectiveGrape::API
   include Grape::Kaminari
 
   default_includes Project, :owner, :admins, :user_project_jobs, project_jobs: [:job], teams: [:team_users]
@@ -43,7 +43,7 @@ class Dummy::ProjectAPI < IntrospectiveGrape::API
 
   class ProjectEntity < Grape::Entity
     expose :id, :name, :created_at, :updated_at
-    expose :owner,  using: Dummy::CompanyAPI::CompanyEntity
+    expose :owner,  using: Dummy::CompanyApi::CompanyEntity
     expose :admins, using: AdminEntity
     expose :project_jobs,      as: :jobs,      using: JobEntity
     expose :user_project_jobs, as: :user_jobs, using: UserJobEntity

data/spec/dummy/app/api/dummy/role_api.rb

@@ -1,4 +1,4 @@
-class Dummy::RoleAPI < IntrospectiveGrape::API
+class Dummy::RoleApi < IntrospectiveGrape::API
   restful Role
 
   class RoleEntity < Grape::Entity

data/spec/dummy/app/api/dummy/sessions.rb

@@ -16,7 +16,7 @@ class Dummy::Sessions < Grape::API #::Instance
       if user && user.valid_password?(params[:password]) && user.valid_for_authentication?
 
         # commented out for now, User model is not yet confirmable
-        #unauthenticated! DummyAPI::USER_NOT_CONFIRMED unless user.confirmed?
+        #unauthenticated! DummyApi::USER_NOT_CONFIRMED unless user.confirmed?
 
         token = nil
         if params[:token]
@@ -28,7 +28,7 @@ class Dummy::Sessions < Grape::API #::Instance
         env['warden'].set_user(user, scope: :user)
         present user, with: Dummy::Entities::User, token: token
       else
-        unauthenticated! DummyAPI::BAD_LOGIN
+        unauthenticated! DummyApi::BAD_LOGIN
       end
     end
 

data/spec/dummy/app/api/dummy/user_api.rb

@@ -1,4 +1,4 @@
-class Dummy::UserAPI < IntrospectiveGrape::API
+class Dummy::UserApi < IntrospectiveGrape::API
 
   skip_presence_validations :password
 

data/spec/dummy/app/api/dummy_api.rb

@@ -1,61 +1,60 @@
-require 'byebug'
-require 'grape-kaminari'
-class DummyAPI < Grape::API #::Instance
-  include Grape::Kaminari
-
-  version 'v1', using: :path
-  format    :json
-  formatter :json, IntrospectiveGrape::Formatter::CamelJson
-  default_format :json
-
-
-  include ErrorHandlers
-  helpers PermissionsHelper
-  helpers APIHelpers
-
-  USER_NOT_CONFIRMED = 'user_not_confirmed'.freeze
-  BAD_LOGIN          = 'bad_login'.freeze
-
-  before do
-    # sets server date in response header. This can be used on the client side
-    header "X-Server-Date", Time.now.to_i.to_s
-    header "Expires", 1.year.ago.httpdate
-  end
-
-  before_validation do
-    Rails.logger.info "With params: #{params.to_hash.inspect}"
-  end
-
-  after do
-    unless self.options[:path].first =~ /swagger/
-      verify_authorized # Ensure that all endpoints are authorized by a policy class
-    end
-  end
-
-  # Load the in-memory database for the test app
-  load "#{Rails.root}/db/schema.rb"
-
-  # Mount every api endpoint under app/api/dummy/.
-  Dir.glob(Rails.root+"app"+"api"+'dummy'+'*.rb').each do |f|
-    api = "Dummy::#{File.basename(f, '.rb').camelize.sub(/Api$/,'API')}"
-    api = api.constantize
-    mount api if api.respond_to? :endpoints
-  end
-
-  # configure grape-swagger to auto-generate swagger docs
-  add_swagger_documentation({
-    base_path:                "/api",
-    doc_version:              'v1',
-    hide_documentation_path:  true,
-    format:                   :json,
-    hide_format:              true,
-    security_definitions: {
-      api_key: {
-        type: "apiKey",
-        name: "api_key",
-        in: "header"
-      }
-    }
-  })
-
-end
+require 'byebug'
+require 'grape-kaminari'
+class DummyApi < Grape::API #::Instance
+  include Grape::Kaminari
+  include ErrorHandlers
+
+  version 'v1', using: :path
+  format    :json
+  formatter :json, IntrospectiveGrape::Formatter::CamelJson
+  default_format :json
+
+  helpers PermissionsHelper
+  helpers AuthenticationHelper
+
+  USER_NOT_CONFIRMED = 'user_not_confirmed'.freeze
+  BAD_LOGIN          = 'bad_login'.freeze
+
+  before do
+    # sets server date in response header. This can be used on the client side
+    header "X-Server-Date", Time.now.to_i.to_s
+    header "Expires", 1.year.ago.httpdate
+  end
+
+  before_validation do
+    Rails.logger.info "With params: #{params.to_hash.inspect}"
+  end
+
+  after do
+    unless self.options[:path].first =~ /swagger/
+      verify_authorized # Ensure that all endpoints are authorized by a policy class
+    end
+  end
+
+  # Load the in-memory database for the test app
+  # load "#{Rails.root}/db/schema.rb"
+
+  # Mount every api endpoint under app/api/dummy/.
+  Dir.glob(Rails.root+"app"+"api"+'dummy'+'*.rb').each do |f|
+    api = "Dummy::#{File.basename(f, '.rb').camelize}"
+    api = api.constantize
+    mount api if api.respond_to? :endpoints
+  end
+
+  # configure grape-swagger to auto-generate swagger docs
+  add_swagger_documentation({
+    base_path:                "/api",
+    doc_version:              'v1',
+    hide_documentation_path:  true,
+    format:                   :json,
+    hide_format:              true,
+    security_definitions: {
+      api_key: {
+        type: "apiKey",
+        name: "api_key",
+        in: "header"
+      }
+    }
+  })
+
+end