introspective_grape 0.4.3 → 0.5.4

data/lib/introspective_grape/filters.rb

@@ -1,113 +1,128 @@
-module IntrospectiveGrape::Filters
-  #
-  # Allow filters on all whitelisted model attributes (from api_params) and declare
-  # customer filters for the index in a method.
-  #
-
-  def default_sort(*args)
-    @default_sort ||= args
-  end
-
-  def custom_filter(*args)
-    custom_filters( *args )
-  end
+module IntrospectiveGrape
+  module Filters
+    # Allow filters on all whitelisted model attributes (from api_params) and declare
+    # customer filters for the index in a method.
 
-  def custom_filters(*args)
-    @custom_filters ||= {}
-    @custom_filters   = Hash[*args].merge(@custom_filters) if args.present?
-    @custom_filters
-  end
+    def default_sort(*args)
+      @default_sort ||= args
+    end
 
-  def filter_on(*args)
-    filters( *args )
-  end
+    def custom_filter(*args)
+      custom_filters( *args )
+    end
 
-  def filters(*args)
-    @filters ||= []
-    @filters   = @filters+args if args.present?
-    @filters
-  end
+    def custom_filters(*args)
+      @custom_filters ||= {}
+      @custom_filters   = Hash[*args].merge(@custom_filters) if args.present?
+      @custom_filters
+    end
 
-  def simple_filters(klass, model, api_params)
-    @simple_filters ||= api_params.select {|p| p.is_a? Symbol }.select {|field|
-      filters.include?(:all) || filters.include?(field)
-    }.map { |field|
-      (klass.param_type(model,field) == DateTime ? ["#{field}_start", "#{field}_end"] : field.to_s)
-    }.flatten
-  end
+    def filter_on(*args)
+      filters( *args )
+    end
 
-  def timestamp_filter(klass,model,field)
-    filter = field.sub(/_(end|start)\z/,'')
-    if field =~ /_(end|start)\z/ && klass.param_type(model,filter) == DateTime
-      filter
-    else
-      false
+    def filters(*args)
+      @filters ||= []
+      @filters  += args if args.present?
+      @filters
     end
-  end
 
-  def identifier_filter(klass,model,field)
-    if field.ends_with?('id') && klass.param_type(model,field) == Integer
-      field
-    else
-      false
+    def simple_filters(klass, model, api_params)
+      @simple_filters ||= api_params.select {|p| p.is_a? Symbol }.select {|field|
+        filters.include?(:all) || filters.include?(field)
+      }.map {|field|
+        (klass.param_type(model, field) == DateTime ? ["#{field}_start", "#{field}_end"] : field.to_s)
+      }.flatten
     end
-  end
 
-  def declare_filter_params(dsl, klass, model, api_params)
-    # Declare optional parameters for filtering parameters, create two parameters per
-    # timestamp, a Start and an End, to apply a date range.
-    simple_filters(klass, model, api_params).each do |field|
-      if timestamp_filter(klass,model,field)
-        terminal = field.ends_with?("_start") ? "initial" : "terminal"
-        dsl.optional field, type: klass.param_type(model,field), description: "Constrain #{field} by #{terminal} date."
-      elsif identifier_filter(klass,model,field)
-        dsl.optional field, type: Array[Integer], coerce_with: ->(val) { val.split(',') }, description: "Filter by a comma separated list of integers."
+    def timestamp_filter(klass, model, field)
+      filter = field.sub(/_(end|start)\z/, '')
+      if field =~ /_(end|start)\z/ && klass.param_type(model, filter) == DateTime
+        filter
       else
-        dsl.optional field, type: klass.param_type(model,field), description: "Filter on #{field} by value."
+        false
       end
     end
 
-    custom_filters.each do |filter,details|
-      dsl.optional filter, details
-    end
+    def declare_filter_params(dsl, klass, model, api_params)
+      # Declare optional parameters for filtering parameters, create two parameters per
+      # timestamp, a Start and an End, to apply a date range.
+      simple_filters(klass, model, api_params).each do |field|
+        declare_simple_filter(dsl, klass, model, field)
+      end
 
-    dsl.optional :filter, type: String, description: "JSON of conditions for query. If you're familiar with ActiveRecord's query conventions you can build more complex filters, e.g. against included child associations, e.g. {\"<association_name>_<parent>\":{\"field\":\"value\"}}" if filters.include?(:all) || filters.include?(:filter)
-  end
+      custom_filters.each do |filter, details|
+        dsl.optional filter, details
+      end
 
+      dsl.optional :filter, type: String, description: filter_doc if special_filter_enabled?(filters)
+    end
 
-  def apply_simple_filter(klass, model, params, records, field)
-    return records if params[field].blank?
+    def declare_simple_filter(dsl, klass, model, field)
+      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.'
+      else
+        dsl.optional field, type: klass.param_type(model, field), description: "Filter on #{field} by value."
+      end
+    end
 
-    if timestamp_filter(klass,model,field)
-      op      = field.ends_with?("_start") ? ">=" : "<="
-      records.where("#{timestamp_filter(klass,model,field)} #{op} ?", Time.zone.parse(params[field]))
-    elsif model.respond_to?("#{field}=")
-      records.send("#{field}=", params[field])
-    else
-      records.where(field => params[field])
+    def humanize_date_range(field)
+      field.ends_with?('_start') ? 'initial' : 'terminal'
     end
-  end
 
-  def apply_filter_params(klass, model, api_params, params, records)
-    records = records.order(default_sort) if default_sort.present?
+    def identifier_filter?(model, field)
+      true if field.ends_with?('id') && %i(integer uuid).include?(model.columns_hash[field]&.type)
+    end
 
-    simple_filters(klass, model, api_params).each do |field|
-      records = apply_simple_filter(klass, model, params, records, field)
+    def special_filter_enabled?(filters)
+      filters.include?(:all) || filters.include?(:filter)
     end
 
-    klass.custom_filters.each do |filter,_details|
-      records = records.send(filter, params[filter])
+    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\"}}
+      STR
     end
 
-    if params[:filter].present?
-      filters = JSON.parse( params[:filter].delete('\\') )
-      filters.each do |key, value|
-        records = records.where(key => value) if value.present?
+    def apply_simple_filter(klass, model, params, records, field)
+      return records if params[field].blank?
+
+      if timestamp_filter(klass, model, field)
+        op      = field.ends_with?('_start') ? '>=' : '<='
+        records.where("#{timestamp_filter(klass, model, field)} #{op} ?", Time.zone.parse(params[field]))
+      elsif model.respond_to?("#{field}=")
+        records.send("#{field}=", params[field])
+      else
+        records.where(field => params[field])
       end
     end
 
-    records.where( JSON.parse(params[:query]) ) if params[:query].present?
+    def apply_filter_params(klass, model, api_params, params, records)
+      records = records.order(default_sort) if default_sort.present?
 
-    records
+      simple_filters(klass, model, api_params).each do |field|
+        records = apply_simple_filter(klass, model, params, records, field)
+      end
+
+      klass.custom_filters.each do |filter, _details|
+        records = records.send(filter, params[filter])
+      end
+
+      records = apply_filters(records, params[:filter])
+      records.where( JSON.parse(params[:query]) ) if params[:query].present?
+      records
+    end
+
+    def apply_filters(records, filters)
+      if filters.present?
+        filters = JSON.parse( filters.delete('\\') )
+        filters.each do |key, value|
+          records = records.where(key => value) if value.present?
+        end
+      end
+      records
+    end
   end
 end

data/lib/introspective_grape/formatter/camel_json.rb

@@ -9,9 +9,8 @@ module IntrospectiveGrape
           # We only need to parse(object.to_json) like this if it isn't already
           # a native hash (or array of them), i.e. we have to parse Grape::Entities
           # and other formatter facades:
-          unless (object.is_a?(Array) && object.first.is_a?(Hash)) || object.is_a?(Hash)
-            object = JSON.parse(object.to_json) if object.respond_to?(:to_json)
-          end
+          has_hash = (object.is_a?(Array) && object.first.is_a?(Hash)) || object.is_a?(Hash)
+          object   = JSON.parse(object.to_json) if object.respond_to?(:to_json) && !has_hash
           CamelSnakeKeys.camel_keys(object)
         end
 

data/lib/introspective_grape/helpers.rb

@@ -1,63 +1,70 @@
-module IntrospectiveGrape::Helpers
-  API_ACTIONS = [:index,:show,:create,:update,:destroy].freeze
-  def authentication_method=(method)
-    # IntrospectiveGrape::API.authentication_method=
-    @authentication_method = method
-  end
+module IntrospectiveGrape
+  module Helpers
+    API_ACTIONS = %i(index show create update destroy).freeze
 
-  def authentication_method(context)
-    # Default to "authenticate!" or as grape docs once suggested, "authorize!"
-    if @authentication_method
-      @authentication_method
-    elsif context.respond_to?('authenticate!')
-      'authenticate!'
-    elsif context.respond_to?('authorize!')
-      'authorize!'
+    def authentication_method=(method)
+      # IntrospectiveGrape::API.authentication_method=
+      @authentication_method = method
     end
-  end
-
-  def paginate(args={})
-    @pagination = args
-  end
 
-  def pagination
-    @pagination
-  end
+    def authentication_method(context)
+      # Default to "authenticate!" or as grape docs once suggested, "authorize!"
+      if @authentication_method
+        @authentication_method
+      elsif context.respond_to?('authenticate!')
+        'authenticate!'
+      elsif context.respond_to?('authorize!')
+        'authorize!'
+      end
+    end
 
-  def exclude_actions(model, *args)
-    @exclude_actions ||= {}; @exclude_actions[model.name] ||= []
-    args.flatten!
-    args = API_ACTIONS if args.include?(:all)
-    args = []          if args.include?(:none)
+    def paginate(args={})
+      @pagination = args
+    end
 
-    undefined_actions = args.compact-API_ACTIONS
-    raise "#{model.name} defines invalid actions: #{undefined_actions}" if undefined_actions.present?
+    def pagination
+      @pagination
+    end
 
-    @exclude_actions[model.name] = args.present? ? args.compact : @exclude_actions[model.name] || []
-  end
+    def exclude_actions(model, *args)
+      args                           = all_or_none(args)
+      @exclude_actions             ||= {}
+      @exclude_actions[model.name] ||= []
 
-  def include_actions(model, *args)
-    @exclude_actions ||= {}; @exclude_actions[model.name] ||= []
-    @exclude_actions[model.name] = API_ACTIONS-exclude_actions(model, args)
-  end
+      undefined_actions = args - API_ACTIONS
+      raise "#{model.name} defines invalid actions: #{undefined_actions}" if undefined_actions.present?
 
+      @exclude_actions[model.name] = args.present? ? args : @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
+    def all_or_none(args=[])
+      args.flatten!&.compact!
+      args = API_ACTIONS if args.include?(:all)
+      args = []          if args.include?(:none)
+      args
+    end
 
-  def whitelist(whitelist=nil)
-    return @whitelist if !whitelist
-    @whitelist = whitelist
-  end
+    def include_actions(model, *args)
+      @exclude_actions             ||= {}
+      @exclude_actions[model.name] ||= []
+      @exclude_actions[model.name] = API_ACTIONS - exclude_actions(model, args)
+    end
 
-  def skip_presence_validations(fields=nil)
-    return @skip_presence_fields||[] if !fields
-    @skip_presence_fields = [fields].flatten
-  end
+    def default_includes(model, *args)
+      @default_includes ||= {}
+      @default_includes[model.name] = args.present? ? args.flatten : @default_includes[model.name] || []
+    end
 
+    def whitelist(whitelist=nil)
+      return @whitelist unless whitelist
 
-end
+      @whitelist = whitelist
+    end
 
+    def skip_presence_validations(fields=nil)
+      return @skip_presence_fields || [] unless fields
 
+      @skip_presence_fields = [fields].flatten
+    end
+  end
+end

data/lib/introspective_grape/snake_params.rb

@@ -1,12 +1,11 @@
 module IntrospectiveGrape
   module SnakeParams
-
     def snake_params_before_validation
       before_validation do
         # We have to snake case the Rack params then re-assign @params to the
         # request.params, because of the I-think-very-goofy-and-inexplicable
         # way Grape interacts with both independently of each other
-        (CamelSnakeKeys.snake_keys(params)||{}).each do |k,v|
+        (CamelSnakeKeys.snake_keys(params) || {}).each do |k, v|
           request.delete_param(k.camelize(:lower))
           request.update_param(k, v)
         end

data/lib/introspective_grape/traversal.rb

@@ -1,54 +1,56 @@
-module IntrospectiveGrape::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)
-    if record
-      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
-  end
-
-  def verify_records_found(leaves, routes)
-    unless (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
-  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]
-        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)
-    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
-  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..-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,34 +1,34 @@
 require 'grape/validations'
-module Grape::Validators
-
-  class Json < Grape::Validations::Base
-    def validate_param!(field, params)
-      begin
-        JSON.parse( params[field] )
-      rescue
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(field)], message: 'must be valid JSON!'
+module Grape
+  module Validators
+    class Json < Grape::Validations::Base
+      def validate_param!(field, params)
+        begin
+          JSON.parse( params[field] )
+        rescue StandardError
+          raise Grape::Exceptions::Validation, params: [@scope.full_name(field)], message: 'must be valid JSON!'
+        end
       end
     end
-  end
 
-  class JsonArray < Grape::Validations::Base
-    def validate_param!(field, params)
-      begin
-        raise unless JSON.parse( params[field] ).kind_of? Array
-      rescue
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(field)], message: 'must be a valid JSON array!'
+    class JsonArray < Grape::Validations::Base
+      def validate_param!(field, params)
+        begin
+          raise unless JSON.parse( params[field] ).is_a? Array
+        rescue StandardError
+          raise Grape::Exceptions::Validation, params: [@scope.full_name(field)], message: 'must be a valid JSON array!'
+        end
       end
     end
-  end
 
-  class JsonHash < Grape::Validations::Base
-    def validate_param!(field, params)
-      begin
-        raise unless JSON.parse( params[field] ).kind_of? Hash
-      rescue
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(field)], message: 'must be a valid JSON hash!'
+    class JsonHash < Grape::Validations::Base
+      def validate_param!(field, params)
+        begin
+          raise unless JSON.parse( params[field] ).is_a? Hash
+        rescue StandardError
+          raise Grape::Exceptions::Validation, params: [@scope.full_name(field)], message: 'must be a valid JSON hash!'
+        end
       end
     end
   end
-
 end

data/lib/introspective_grape/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module IntrospectiveGrape
-  VERSION = "0.4.3".freeze
+  VERSION = '0.5.4'
 end

data/spec/dummy/.ruby-version

@@ -0,0 +1 @@
+2.6.0

data/spec/dummy/Gemfile

@@ -1,7 +1,7 @@
 source 'https://rubygems.org'
-gem 'rails'
+gem 'rails', '5.2.6'
 
-#gem 'byebug'
+gem 'byebug'
 gem 'camel_snake_keys'
 
 gem 'devise'
@@ -12,10 +12,11 @@ gem 'grape'
 gem 'grape-entity'
 gem 'grape-kaminari'
 gem 'grape-swagger'
-gem 'introspective_grape',  git: 'https://github.com/buermann/introspective_grape', branch: 'grape-1.2'
+gem 'grape-swagger-entity'
+gem 'introspective_grape', path: '~/Dropbox/contrib/introspective_grape'
 
 gem 'paperclip'
 gem 'pundit'
 
 gem 'rack-cors'
-gem 'sqlite3', '< 1.4.0'
+gem 'sqlite3'

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

@@ -2,7 +2,7 @@ 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")
+    @user = User.find_or_create_by(email: 'test@test.com', superuser: true, authentication_token: '1234567890', first_name: "First", last_name: "Last")
   end
 
   def authenticate!

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

@@ -5,7 +5,7 @@ class Dummy::CompanyAPI < IntrospectiveGrape::API
 
     desc "Test default values in an extra endpoint"
     params do
-      optional :boolean_default, type: Virtus::Attribute::Boolean, default: false
+      optional :boolean_default, type: Boolean, default: false
       optional :string_default, type: String, default: "foo"
       optional :integer_default, type: Integer, default: 123
     end
@@ -14,6 +14,15 @@ class Dummy::CompanyAPI < IntrospectiveGrape::API
       present params
     end
 
+    desc "Test kaminari pagination in a custom index"
+    params do
+      use :pagination
+    end
+    get '/paginated/list' do
+      authorize Company.new, :index?
+      companies = Company.all
+      present paginate(companies), using: CompanyEntity
+    end
   end
 
   class CompanyEntity < Grape::Entity

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

@@ -1,4 +1,5 @@
 class Dummy::ProjectAPI < IntrospectiveGrape::API
+  include Grape::Kaminari
 
   default_includes Project, :owner, :admins, :user_project_jobs, project_jobs: [:job], teams: [:team_users]
   default_includes Team, :team_users

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

@@ -1,4 +1,4 @@
-class Dummy::Sessions < Grape::API
+class Dummy::Sessions < Grape::API #::Instance
 
   resource :sessions do
 

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

@@ -1,9 +1,14 @@
-class DummyAPI < Grape::API
+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
@@ -32,7 +37,8 @@ class DummyAPI < Grape::API
 
   # 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')}".constantize
+    api = "Dummy::#{File.basename(f, '.rb').camelize.sub(/Api$/,'API')}"
+    api = api.constantize
     mount api if api.respond_to? :endpoints
   end
 

data/spec/dummy/app/assets/config/manifest.js

@@ -0,0 +1,4 @@
+//= link_tree ../images
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css
+