Merge branch 'feature/ransack-scopes' into easypep-master

Author: fluxsaas

lib/jsonapi/filtering.rb

@@ -35,9 +35,11 @@ def self.extract_attributes_and_predicates(requested_field, allowed_fields)
     # @param allowed_fields [Array] a list of allowed fields to be filtered
     # @param options [Hash] extra flags to enable/disable features
     # @return [ActiveRecord::Base] a collection of resources
-    def jsonapi_filter(resources, allowed_fields, options = {})
+    def jsonapi_filter(resources, allowed_fields, *allowed_scopes, options)
+      options = options || {}
+      allowed_scopes = (allowed_scopes || []).flatten.map(&:to_s)
       allowed_fields = allowed_fields.map(&:to_s)
-      extracted_params = jsonapi_filter_params(allowed_fields)
+      extracted_params = jsonapi_filter_params(allowed_fields, allowed_scopes)
       extracted_params[:sorts] = jsonapi_sort_params(allowed_fields, options)
       resources = resources.ransack(extracted_params)
       block_given? ? yield(resources) : resources
@@ -50,7 +52,7 @@ def jsonapi_filter(resources, allowed_fields, options = {})
     #
     # @param allowed_fields [Array] a list of allowed fields to be filtered
     # @return [Hash] to be passed to [ActiveRecord::Base#order]
-    def jsonapi_filter_params(allowed_fields)
+    def jsonapi_filter_params(allowed_fields, allowed_scopes)
       filtered = {}
       requested = params[:filter] || {}
       allowed_fields = allowed_fields.map(&:to_s)
@@ -65,6 +67,20 @@ def jsonapi_filter_params(allowed_fields)
           to_filter = to_filter.split(',')
         end
 
+        # filter by scopes expects an exact match
+        # with the `allowed_scopes`. Predicates can be a part of named scopes
+        # and should be handled first
+        # Make sure to move to the next after a match
+        # {"created_before"=>"2013-02-01"}
+        # {"created_before_gt"=>"2013-02-01"}
+        if allowed_scopes.include?(requested_field)
+          filtered[requested_field] = to_filter
+          next
+        end
+
+
+        # filter by attributes
+        # {"first_name_eq"=>"Beau"}
         if predicates.any? && (field_names - allowed_fields).empty?
           filtered[requested_field] = to_filter
         end

spec/dummy.rb

@@ -32,6 +32,11 @@
 
 class User < ActiveRecord::Base
   has_many :notes
+  scope :created_before, ->(date) { where('created_at < ?', date) }
+
+  def self.ransackable_scopes(auth_object = nil)
+    %i(created_before)
+  end
 end
 
 class Note < ActiveRecord::Base
@@ -87,9 +92,15 @@ def index
       :notes_created_at, :notes_quantity,
       :notes_count
     ]
+    allowed_scopes = [
+      :created_before
+    ]
     options = { sort_with_expressions: true }
 
-    jsonapi_filter(User.all, allowed_fields, options) do |filtered|
+    jsonapi_filter(User.all,
+                   allowed_fields,
+                   allowed_scopes,
+                   options) do |filtered|
       result = filtered.result
 
       if params[:sort].to_s.include?('notes_quantity')

spec/filtering_spec.rb

@@ -135,6 +135,29 @@
           expect(response_json['data'][0]).to have_id(second_user.id.to_s)
         end
       end
+
+      context 'returns users filtered by scope' do
+        let(:params) do
+          third_user.update(created_at: '2013-01-01')
+
+          {
+            filter: { created_before: '2013-02-01' }
+          }
+        end
+
+        it 'ensures ransack scopes are working properly' do
+          ransack = User.ransack({ created_before: '2013-02-01' })
+          expected_sql = 'SELECT "users".* FROM "users" WHERE '\
+                         '(created_at < \'2013-02-01\')'
+          expect(ransack.result.to_sql).to eq(expected_sql)
+        end
+
+        it 'should return only' do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].size).to eq(1)
+          expect(response_json['data'][0]).to have_id(third_user.id.to_s)
+        end
+      end
     end
   end
 end