Refactor scope logic

* Introduce Query class which will parse incoming params into something
we can work with.
* Introduce Scope so we can call resolve and handle association loading
* General refactoring

Author: Lee Richmond

Gemfile

@@ -4,6 +4,8 @@ source "https://rubygems.org"
 gemspec
 
 group :test do
+  gem 'pry'
+  gem 'pry-byebug', platform: [:mri]
   gem 'appraisal'
   gem 'guard'
   gem 'guard-rspec'

lib/jsonapi_compliable.rb

@@ -3,20 +3,21 @@
 require "jsonapi_compliable/version"
 require "jsonapi_compliable/errors"
 require "jsonapi_compliable/dsl"
-require "jsonapi_compliable/scope/base"
-require "jsonapi_compliable/scope/sort"
-require "jsonapi_compliable/scope/paginate"
-require "jsonapi_compliable/scope/sideload"
-require "jsonapi_compliable/scope/extra_fields"
-require "jsonapi_compliable/scope/filterable"
-require "jsonapi_compliable/scope/default_filter"
-require "jsonapi_compliable/scope/filter"
+require "jsonapi_compliable/query"
+require "jsonapi_compliable/scope"
+require "jsonapi_compliable/scoping/base"
+require "jsonapi_compliable/scoping/sort"
+require "jsonapi_compliable/scoping/paginate"
+require "jsonapi_compliable/scoping/sideload"
+require "jsonapi_compliable/scoping/extra_fields"
+require "jsonapi_compliable/scoping/filterable"
+require "jsonapi_compliable/scoping/default_filter"
+require "jsonapi_compliable/scoping/filter"
 require "jsonapi_compliable/stats/dsl"
 require "jsonapi_compliable/stats/payload"
 require "jsonapi_compliable/util/include_params"
 require "jsonapi_compliable/util/field_params"
-require "jsonapi_compliable/util/scoping"
-require "jsonapi_compliable/util/pagination"
+require "jsonapi_compliable/util/hash"
 require "jsonapi_compliable/extensions/extra_attribute"
 require "jsonapi_compliable/extensions/boolean_attribute"
 

lib/jsonapi_compliable/base.rb

@@ -9,60 +9,45 @@ module Base
       class_attribute :_jsonapi_compliable
       attr_reader :_jsonapi_scope
 
-      before_action :parse_fieldsets!
-      after_action :reset_scope_flag
+      around_action :wrap_context
     end
 
-    def default_page_number
-      1
-    end
-
-    def default_page_size
-      20
-    end
-
-    def default_sort
-      'id'
+    # TODO pass controller and action name here to guard
+    def wrap_context
+      _jsonapi_compliable.with_context(self, action_name.to_sym) do
+        yield
+      end
     end
 
-    def jsonapi_scope(scope,
-                      filter: true,
-                      includes: true,
-                      paginate: true,
-                      extra_fields: true,
-                      sort: true)
-      scope = JsonapiCompliable::Scope::DefaultFilter.new(self, scope).apply
-      scope = JsonapiCompliable::Scope::Filter.new(self, scope).apply if filter
-      scope = JsonapiCompliable::Scope::ExtraFields.new(self, scope).apply if extra_fields
-      scope = JsonapiCompliable::Scope::Sideload.new(self, scope).apply if includes
-      scope = JsonapiCompliable::Scope::Sort.new(self, scope).apply if sort
-      # This is set before pagination so it can be re-used for stats
-      @_jsonapi_scope = scope
-      scope = JsonapiCompliable::Scope::Paginate.new(self, scope).apply if paginate
-      scope
+    def jsonapi_scope(scope, opts = {})
+      query = Query.new(_jsonapi_compliable, params)
+      _jsonapi_compliable.build_scope(scope, query, opts)
     end
 
-    def reset_scope_flag
-      @_jsonapi_scope = nil
-    end
+    # TODO: refactor
+    def render_jsonapi(scope, opts = {})
+      query = Query.new(_jsonapi_compliable, params)
+      query_hash = query.to_hash[_jsonapi_compliable.type]
 
-    def parse_fieldsets!
-      Util::FieldParams.parse!(params, :fields)
-      Util::FieldParams.parse!(params, :extra_fields)
-    end
+      scoped = scope
+      scoped = jsonapi_scope(scoped) unless opts[:scope] == false || scoped.is_a?(JsonapiCompliable::Scope)
+      resolved = scoped.respond_to?(:resolve) ? scoped.resolve : scoped
 
-    def render_jsonapi(scope, opts = {})
-      scoped = Util::Scoping.apply?(self, scope, opts.delete(:scope)) ? jsonapi_scope(scope) : scope
       options = default_jsonapi_render_options
-      options[:include] = forced_includes || Util::IncludeParams.scrub(self)
-      options[:jsonapi] = JsonapiCompliable::Util::Pagination.zero?(params) ? [] : scoped
-      options[:fields] = Util::FieldParams.fieldset(params, :fields) if params[:fields]
+      options[:include] = forced_includes || Util::IncludeParams.scrub(query_hash[:include], _jsonapi_compliable.allowed_sideloads)
+      options[:jsonapi] = resolved
+      options[:fields] = query.fieldsets
       options[:meta] ||= {}
       options.merge!(opts)
-      options[:meta][:stats] = Stats::Payload.new(self, scoped).generate if params[:stats]
+
+      if scoped.respond_to?(:resolve_stats)
+        stats = scoped.resolve_stats
+        options[:meta][:stats] = stats unless stats.empty?
+      end
+
       options[:expose] ||= {}
       options[:expose][:context] = self
-      options[:expose][:extra_fields] = Util::FieldParams.fieldset(params, :extra_fields) if params[:extra_fields]
+      options[:expose][:extra_fields] = query_hash[:extra_fields]
 
       render(options)
     end
@@ -74,6 +59,7 @@ def default_jsonapi_render_options
       end
     end
 
+    # Legacy
     # TODO: This nastiness likely goes away once jsonapi standardizes
     # a spec for nested relationships.
     # See: https://github.com/json-api/json-api/issues/1089
@@ -95,6 +81,7 @@ def forced_includes(data = nil)
       end
     end
 
+    # Legacy
     def force_includes?
       %w(PUT PATCH POST).include?(request.method) and
         raw_params.try(:[], :data).try(:[], :relationships).present?

lib/jsonapi_compliable/dsl.rb

@@ -8,6 +8,8 @@ class DSL
       :stats,
       :pagination
 
+    attr_reader :context
+
     def initialize
       clear!
     end
@@ -32,6 +34,73 @@ def clear!
       @stats = {}
       @sorting = nil
       @pagination = nil
+      @context = {}
+    end
+
+    def with_context(object, namespace = nil)
+      begin
+        prior = @context
+        @context = { object: object, namespace: namespace }
+        yield
+      ensure
+        @context = prior
+      end
+    end
+
+    def build_scope(base, query, opts = {})
+      Scope.new(base, self, query, opts)
+    end
+
+    def default_sort(val = nil)
+      if val
+        @default_sort = val
+      else
+        @default_sort || [{ id: :asc }]
+      end
+    end
+
+    def default_page_number(val = nil)
+      if val
+        @default_page_number = val
+      else
+        @default_page_number || 1
+      end
+    end
+
+    def default_page_size(val = nil)
+      if val
+        @default_page_size = val
+      else
+        @default_page_size || 20
+      end
+    end
+
+    def association_names
+      @association_names ||= begin
+        if whitelist = @sideloads[:whitelist]
+          Util::Hash.keys(whitelist.to_hash.values.reduce(&:merge))
+        else
+          []
+        end
+      end
+    end
+
+    def allowed_sideloads
+      return {} if @sideloads.empty?
+
+      if namespace = @context[:namespace]
+        @sideloads[:whitelist][namespace].to_hash
+      else
+        @sideloads[:whitelist].to_hash.values.reduce(&:merge)
+      end
+    end
+
+    def type(value = nil)
+      if value
+        @type = value
+      else
+        @type || :undefined_jsonapi_type
+      end
     end
 
     def includes(whitelist: nil, &blk)
@@ -73,12 +142,8 @@ def paginate(&blk)
       @pagination = blk
     end
 
-    def extra_field(field, &blk)
-      @extra_fields[field.keys.first] ||= []
-      @extra_fields[field.keys.first] << {
-        name: field.values.first,
-        proc: blk
-      }
+    def extra_field(name, &blk)
+      @extra_fields[name] = blk
     end
 
     def stat(attribute, calculation)

lib/jsonapi_compliable/extensions/extra_attribute.rb

@@ -14,11 +14,7 @@ def extra_attribute(name, options = {}, &blk)
               next false unless instance_eval(&options[:if])
             end
 
-            if @extra_fields && @extra_fields[jsonapi_type]
-              @extra_fields[jsonapi_type].include?(name)
-            else
-              false
-            end
+            @extra_fields.include?(name)
           }
 
           attribute name, if: allow_field, &blk

lib/jsonapi_compliable/query.rb

@@ -0,0 +1,144 @@
+# TODO: refactor - code could be better but it's a one-time thing.
+
+module JsonapiCompliable
+  class Query
+    attr_reader :params, :dsl
+
+    def self.default_hash
+      {
+        filter: {},
+        sort: [],
+        page: {},
+        include: {},
+        extra_fields: [],
+        fields: [],
+        stats: {}
+      }
+    end
+
+    def initialize(dsl, params)
+      @dsl = dsl
+      @params = params
+    end
+
+    def to_hash
+      hash = { dsl.type => self.class.default_hash }
+      dsl.association_names.each do |name|
+        hash[name] = self.class.default_hash.except(:include)
+      end
+
+      parse_fields(hash, :fields)
+      parse_fields(hash, :extra_fields)
+      parse_filter(hash)
+      parse_sort(hash)
+      parse_pagination(hash)
+      parse_include(hash)
+      parse_stats(hash)
+
+      hash
+    end
+
+    # TODO: test
+    def fieldsets
+      {}.tap do |fs|
+        to_hash.each_pair do |namespace, query_hash|
+          if query_hash[:fields] and !query_hash[:fields].empty?
+            fs[namespace] = query_hash[:fields]
+          end
+        end
+      end
+    end
+
+    def zero_results?
+      !@params[:page].nil? &&
+        !@params[:page][:size].nil? &&
+        @params[:page][:size].to_i == 0
+    end
+
+    private
+
+    def association?(name)
+      dsl.association_names.include?(name)
+    end
+
+    # TODO: maybe walk the graph and apply to all
+    def parse_include(hash)
+      hash[dsl.type][:include] = JSONAPI::IncludeDirective.new(params[:include] || {}).to_hash
+    end
+
+    def parse_stats(hash)
+      if params[:stats]
+        params[:stats].each_pair do |namespace, calculations|
+          if namespace == dsl.type || association?(namespace)
+            calculations.each_pair do |name, calcs|
+              hash[namespace][:stats][name] = calcs.split(',').map(&:to_sym)
+            end
+          else
+            hash[dsl.type][:stats][namespace] = calculations.split(',').map(&:to_sym)
+          end
+        end
+      end
+    end
+
+    def parse_fields(hash, type)
+      field_params = Util::FieldParams.parse(params[type])
+      field_params.each_pair do |namespace, fields|
+        hash[namespace][type] = fields
+      end
+    end
+
+    def parse_filter(hash)
+      if filter = params[:filter]
+        filter.each_pair do |key, value|
+          key = key.to_sym
+
+          if association?(key)
+            hash[key][:filter].merge!(value)
+          else
+            hash[dsl.type][:filter][key] = value
+          end
+        end
+      end
+    end
+
+    def parse_sort(hash)
+      if sort = params[:sort]
+        sorts = sort.split(',')
+        sorts.each do |s|
+          if s.include?('.')
+            type, attr = s.split('.')
+            if type.starts_with?('-')
+              type = type.sub('-', '')
+              attr = "-#{attr}"
+            end
+
+            hash[type.to_sym][:sort] << sort_attr(attr)
+          else
+            hash[dsl.type][:sort] << sort_attr(s)
+          end
+        end
+      end
+    end
+
+    def parse_pagination(hash)
+      if pagination = params[:page]
+        pagination.each_pair do |key, value|
+          key = key.to_sym
+
+          if [:number, :size].include?(key)
+            hash[dsl.type][:page][key] = value.to_i
+          else
+            hash[key][:page] = { number: value[:number].to_i, size: value[:size].to_i }
+          end
+        end
+      end
+    end
+
+    def sort_attr(attr)
+      value = attr.starts_with?('-') ? :desc : :asc
+      key   = attr.sub('-', '').to_sym
+
+      { key => value }
+    end
+  end
+end