fetcheable_on_api 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 526e0f21adee665430b54272194fb618c1fb6de3b1ddd8304c1e503ea7038d12
-  data.tar.gz: 36475791e8222dca95087228f221e2a90151fe8e0da0d3380445cd5892409a3e
+  metadata.gz: d557420a13e2668f210f92dd25263770b8345dc82b1cc68ec49171028a708b0c
+  data.tar.gz: e4c9edbd515862b132c67d6a8cefd4a2e3d76283d931ffa7d9f43b436f271ef3
 SHA512:
-  metadata.gz: 7fea1bcc86e766c6bf3047b3b0bf7c1657abcd8d03df98e1a8c1eff279a6acf8b5c40859edb66e48e530a835a769a6a8b33c01a5d98d1cedc9e31d1df0d861c5
-  data.tar.gz: 21ef10f2fa41413ccc14ed66e511b38f5d6e8268de989423640b4ea486859af1c6247641f86505ceaf95fb39fa639903ffe57d06fea65c8ef0ad7cbe93050242
+  metadata.gz: 5154c9bf6a13a635cbad72e6ab9f3a793598e3082c92714d397ef3f81687df8d69f83b6ab80c723cdb544f19e50479e79a2e43519e689ec0102f92a021c9c4bc
+  data.tar.gz: 8de8a403e545f21477c2d2124d0c92a765ef1eae194d3635fc233352c4157086aaf03a4864987e571dfddecdbf70e1ce68c5182efb0e42aef99d1f7831bc01f8

data/README.md

@@ -433,10 +433,131 @@ $ curl -X GET \
 ]
 ```
 
-Currently two kind of predicates are supported:
+Currently 33 predicates are supported ([more details here](https://github.com/fabienpiette/fetcheable_on_api/wiki/Predicates)):
 
-+ `:ilike` which is the default behaviour and will match the parameter with the SQL fragment `ILIKE '%foo%'`.
++ `:between`
++ `:does_not_match`
++ `:does_not_match_all`
++ `:does_not_match_any`
 + `:eq` which matches the parameter with the SQL fragment `= 'foo'`.
++ `:eq_all`
++ `:eq_any`
++ `:gt`
++ `:gt_all`
++ `:gt_any`
++ `:gteq`
++ `:gteq_all`
++ `:gteq_any`
++ `:ilike` which is the default behaviour and will match the parameter with the SQL fragment `ILIKE '%foo%'`.
++ `:in`
++ `:in_all`
++ `:in_any`
++ `:lt`
++ `:lt_all`
++ `:lt_any`
++ `:lteq`
++ `:lteq_all`
++ `:lteq_any`
++ `:matches`
++ `:matches_all`
++ `:matches_any`
++ `:not_between`
++ `:not_eq`
++ `:not_eq_all`
++ `:not_eq_any`
++ `:not_in`
++ `:not_in_all`
++ `:not_in_any`
+
++ `lamdba` wich take two arguments: a collection and a value, then return an Arel predicate.
+  ```ruby
+  filter_by :name, with: -> (collection, value) do
+    collection.arel_table[:first_name].matches("%#{value}%").or(
+      collection.arel_table[:last_name].matches("%#{value}%"),
+    )
+  end
+  ```
+
+You can also use an array as a parameter for some predicate
+
+```ruby
+class QuestionsController < ActionController::Base
+  #
+  # FetcheableOnApi
+  #
+  filter_by :id, with: :between
+
+  # GET /questions
+  def index
+    questions = apply_fetcheable(Question.includes(:answer).all)
+    render json: questions
+  end
+end
+```
+
+```bash
+curl -X GET \
+  'http://localhost:3000/questions?filter[id]=[1]'
+
+[
+    {
+        "id": 1,
+        "position": 1,
+        "content": "Je peux boire ou cuisiner avec l'eau de pluie ?",
+        "answer": "Faux : l'eau de pluie que vous récupérez est strictement interdite pour une consommation alimentaire car elle n'est pas potable.\nVous ne devez donc pas la boire, ni l'utiliser pour cuisiner ou laver la vaisselle.\n",
+        "base_value": false
+    }
+]
+```
+
+Date manipulation is a special case and can be solved by specifically indicating the expected format for the parameter.
+
+```ruby
+class QuestionsController < ActionController::Base
+  #
+  # FetcheableOnApi
+  #
+  filter_by :created_at,
+            with: :between,
+            format: :datetime
+
+  # GET /questions
+  def index
+    questions = apply_fetcheable(Question.includes(:answer).all)
+    render json: questions
+  end
+end
+```
+
+```bash
+curl -X GET \
+  'http://localhost:3000/questions?filter[created_at]=[1541428932,1541428933]'
+```
+
+By default the format used is epoch time, but you can redefine it by overriding the method `foa_string_to_datetime`
+
+```ruby
+class QuestionsController < ActionController::Base
+  #
+  # FetcheableOnApi
+  #
+  filter_by :created_at,
+            with: :between,
+            format: :datetime
+
+  # GET /questions
+  def index
+    questions = apply_fetcheable(Question.includes(:answer).all)
+    render json: questions
+  end
+
+  protected
+
+  def foa_string_to_datetime(string)
+    DateTime.strptime(string, '%s')
+  end
+end
+```
 
 And that's all !
 

data/lib/fetcheable_on_api.rb

@@ -6,6 +6,7 @@ require 'fetcheable_on_api/pagineable'
 require 'fetcheable_on_api/sortable'
 require 'fetcheable_on_api/version'
 require 'active_support'
+require 'date'
 
 module FetcheableOnApi
   #
@@ -26,7 +27,8 @@ module FetcheableOnApi
   #
   # Supports
   #
-  ArgumentError = Class.new(ArgumentError)
+  ArgumentError       = Class.new(ArgumentError)
+  NotImplementedError = Class.new(NotImplementedError)
 
   #
   # Public class methods
@@ -55,25 +57,29 @@ module FetcheableOnApi
     apply_pagination(collection)
   end
 
-  def valid_parameters!(*keys, permitted_types: default_permitted_types)
+  def foa_valid_parameters!(*keys, foa_permitted_types: foa_default_permitted_types)
     raise FetcheableOnApi::ArgumentError.new(
       "Incorrect type #{params.dig(*keys).class} for params #{keys}"
-    ) unless valid_params_types(*keys, permitted_types: permitted_types)
+    ) unless foa_valid_params_types(*keys, foa_permitted_types: foa_permitted_types)
   end
 
-  def valid_params_types(*keys, permitted_types: default_permitted_types)
-    permitted_types.inject(false) do |res, type|
-      res || valid_params_type(params.dig(*keys), type)
+  def foa_valid_params_types(*keys, foa_permitted_types: foa_default_permitted_types)
+    foa_permitted_types.inject(false) do |res, type|
+      res || foa_valid_params_type(params.dig(*keys), type)
     end
   end
 
-  def valid_params_type(value, type)
+  def foa_valid_params_type(value, type)
     value.is_a?(type)
   end
 
-  def default_permitted_types
+  def foa_default_permitted_types
     [ActionController::Parameters, Hash]
   end
+
+  def foa_string_to_datetime(string)
+    DateTime.strptime(string, '%s')
+  end
 end
 
 ActiveSupport.on_load :action_controller do

data/lib/fetcheable_on_api/filtreable.rb

@@ -12,7 +12,7 @@ module FetcheableOnApi
     def self.included(base)
       base.class_eval do
         extend ClassMethods
-        class_attribute :filters_configuration, :instance_writer => false
+        class_attribute :filters_configuration, instance_writer: false
         self.filters_configuration = {}
       end
     end
@@ -21,7 +21,7 @@ module FetcheableOnApi
       def filter_by(*attrs)
         options = attrs.extract_options!
         options.symbolize_keys!
-        options.assert_valid_keys(:as, :class_name, :with)
+        options.assert_valid_keys(:as, :class_name, :with, :format)
 
         self.filters_configuration = filters_configuration.dup
 
@@ -44,27 +44,104 @@ module FetcheableOnApi
     #
     protected
 
+    def try_parse_array(values, format)
+      array = JSON.parse(values)
+      array.map! { |el| foa_string_to_datetime(el.to_s) } if format == :datetime
+
+      [array]
+    rescue JSON::ParserError
+      nil
+    end
+
     def apply_filters(collection)
       return collection if params[:filter].blank?
-      valid_parameters!(:filter)
+      foa_valid_parameters!(:filter)
 
       filter_params = params.require(:filter)
                             .permit(filters_configuration.keys)
                             .to_hash
 
       filtering = filter_params.map do |column, values|
-        values.split(',').map do |value|
+        format     = filters_configuration[column.to_sym].fetch(:format, :string)
+        elements   = try_parse_array(values, format)
+        elements ||= values.split(',')
+
+        elements.map do |value|
           column_name = filters_configuration[column.to_sym].fetch(:as, column)
           klass       = filters_configuration[column.to_sym].fetch(:class_name, collection.klass)
           predicate   = filters_configuration[column.to_sym].fetch(:with, :ilike)
 
           case predicate
-          when :ilike
-            klass.arel_table[column_name].matches("%#{value}%")
+          when :between
+            klass.arel_table[column_name].between(value.first..value.last)
+          when :does_not_match
+            klass.arel_table[column_name].does_not_match("%#{value}%")
+          when :does_not_match_all
+            klass.arel_table[column_name].does_not_match_all(value)
+          when :does_not_match_any
+            klass.arel_table[column_name].does_not_match_any(value)
           when :eq
             klass.arel_table[column_name].eq(value)
+          when :eq_all
+            klass.arel_table[column_name].eq_all(value)
+          when :eq_any
+            klass.arel_table[column_name].eq_any(value)
+          when :gt
+            klass.arel_table[column_name].gt(value)
+          when :gt_all
+            klass.arel_table[column_name].gt_all(value)
+          when :gt_any
+            klass.arel_table[column_name].gt_any(value)
+          when :gteq
+            klass.arel_table[column_name].gteq(value)
+          when :gteq_all
+            klass.arel_table[column_name].gteq_all(value)
+          when :gteq_any
+            klass.arel_table[column_name].gteq_any(value)
+          when :in
+            klass.arel_table[column_name].in(value)
+          when :in_all
+            klass.arel_table[column_name].in_all(value)
+          when :in_any
+            klass.arel_table[column_name].in_any(value)
+          when :lt
+            klass.arel_table[column_name].lt(value)
+          when :lt_all
+            klass.arel_table[column_name].lt_all(value)
+          when :lt_any
+            klass.arel_table[column_name].lt_any(value)
+          when :lteq
+            klass.arel_table[column_name].lteq(value)
+          when :lteq_all
+            klass.arel_table[column_name].lteq_all(value)
+          when :lteq_any
+            klass.arel_table[column_name].lteq_any(value)
+          when :ilike
+            klass.arel_table[column_name].matches("%#{value}%")
+          when :matches
+            klass.arel_table[column_name].matches(value)
+          when :matches_all
+            klass.arel_table[column_name].matches_all(value)
+          when :matches_any
+            klass.arel_table[column_name].matches_any(value)
+          when :not_between
+            klass.arel_table[column_name].not_between(value.first..value.last)
+          when :not_eq
+            klass.arel_table[column_name].not_eq(value)
+          when :not_eq_all
+            klass.arel_table[column_name].not_eq_all(value)
+          when :not_eq_any
+            klass.arel_table[column_name].not_eq_any(value)
+          when :not_in
+            klass.arel_table[column_name].not_in(value)
+          when :not_in_all
+            klass.arel_table[column_name].not_in_all(value)
+          when :not_in_any
+            klass.arel_table[column_name].not_in_any(value)
           else
-            raise ArgumentError, "unsupported predicate `#{predicate}`"
+            raise ArgumentError, "unsupported predicate `#{predicate}`" unless predicate.respond_to?(:call)
+
+            predicate.call(collection, value)
           end
         end.inject(:or)
       end

data/lib/fetcheable_on_api/pagineable.rb

@@ -21,7 +21,7 @@ module FetcheableOnApi
 
     def apply_pagination(collection)
       return collection if params[:page].blank?
-      valid_parameters!(:page)
+      foa_valid_parameters!(:page)
 
       limit = params[:page].fetch(
         :size,

data/lib/fetcheable_on_api/sortable.rb

@@ -49,7 +49,7 @@ module FetcheableOnApi
 
     def apply_sort(collection)
       return collection if params[:sort].blank?
-      valid_parameters!(:sort, permitted_types: [String])
+      foa_valid_parameters!(:sort, permitted_types: [String])
 
       ordering      = {}
       sorted_params = params[:sort].split(',')

data/lib/fetcheable_on_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FetcheableOnApi
-  VERSION = '0.1.7'.freeze
+  VERSION = '0.1.8'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fetcheable_on_api
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Fabien
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-03 00:00:00.000000000 Z
+date: 2018-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport