General refactor

Break up module into separate classes, so we don't pollute controllers
and have better code organization.

Author: Lee Richmond

lib/jsonapi_compliable.rb

@@ -5,6 +5,16 @@
 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/util/include_params"
+require "jsonapi_compliable/util/field_params"
 
 module JSONAPICompliable
   autoload :Base,           'jsonapi_compliable/base'

lib/jsonapi_compliable/base.rb

@@ -7,115 +7,9 @@ module Base
 
     included do
       class_attribute :_jsonapi_compliable
-
-      def self.inherited(klass)
-        klass._jsonapi_compliable = nil
-      end
-
       before_action :parse_fieldsets!
     end
 
-    # Private to module
-    class CompareIncludes
-      def self.call(includes, whitelist)
-        {}.tap do |valid|
-          includes.to_hash.each_pair do |key, sub_hash|
-            if whitelist[key]
-              valid[key] = CompareIncludes.call(sub_hash, whitelist[key])
-            end
-          end
-        end
-      end
-    end
-
-    # Converts include params like foo.bar,baz
-    # to AMS-compliant
-    # {foo: {bar: {}}, baz: {}}
-    #
-    # Ensures they are part of the whitelist
-    def scrub_includes
-      return unless params[:include]
-
-      includes = _jsonapi_compliable.parse_includes(params[:include])
-      whitelist = _jsonapi_compliable.sideloads[:whitelist][params[:action]]
-      whitelist ? CompareIncludes.call(includes, whitelist) : {}
-    end
-
-    def jsonapi_includes(scope)
-      scrubbed = scrub_includes
-      return scope unless scrubbed
-
-      scope = if custom_include = _jsonapi_compliable.sideloads[:custom_function]
-                custom_include.call(scope, scrubbed)
-              else
-                scope.includes(scrubbed)
-              end
-
-      scope
-    end
-
-    def jsonapi_sort(scope)
-      sort_param = params[:sort] || 'id'
-      dir = sort_param.starts_with?('-') ? :desc : :asc
-      att = sort_param.sub('-', '').to_sym
-
-      scope = if custom_sort = _jsonapi_compliable.sorting
-                custom_sort.call(scope, att, dir)
-              else
-                scope.order(att => dir)
-              end
-
-      scope
-    end
-
-    def jsonapi_paginate(scope)
-      page_param = params[:page] || {}
-      number     = (page_param[:number] || default_page_number).to_i
-      size       = (page_param[:size]   || default_page_size).to_i
-
-      if size > MAX_PAGE_SIZE
-        raise JSONAPICompliable::Errors::UnsupportedPageSize,"Requested page size #{size} is greater than max supported size #{MAX_PAGE_SIZE}" 
-      end
-
-      scope = if custom_pagination = _jsonapi_compliable.pagination
-                custom_pagination.call(scope, number, size)
-              else
-                scope.page(number).per(size)
-              end
-
-      scope
-    end
-
-    def jsonapi_filter(scope)
-      param_filters = params[:filter] || {}
-      scope = _jsonapi_compliable.default_filter_scope(self, scope)
-      param_filters.each_pair do |param_name, param_value|
-        scope = _jsonapi_compliable.filter_scope(self, scope, param_name, param_value)
-      end
-
-      scope
-    end
-
-    def jsonapi_extra_fields(scope)
-      _jsonapi_compliable.extra_fields.each_pair do |namespace, extra_fields|
-        extra_fields.each do |extra_field|
-          if requested_extra_field?(namespace, extra_field[:name])
-            scope = extra_field[:proc].call(scope)
-          end
-        end
-      end
-
-      scope
-    end
-
-    def requested_extra_field?(namespace, field)
-      if namespaced = params[:extra_fields].try(:[], namespace)
-        namespaced.include?(field)
-      else
-        false
-      end
-    end
-
     def default_page_number
       1
     end
@@ -130,44 +24,29 @@ def jsonapi_scope(scope,
                       paginate: true,
                       extra_fields: true,
                       sort: true)
-      scope = jsonapi_filter(scope) if filter
-      scope = jsonapi_extra_fields(scope) if extra_fields
-      scope = jsonapi_includes(scope) if includes
-      scope = jsonapi_sort(scope) if sort
-      scope = jsonapi_paginate(scope) if paginate
+      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
+      scope = JSONAPICompliable::Scope::Paginate.new(self, scope).apply if paginate
       scope
     end
 
-    def fieldset(name)
-      params[name].to_unsafe_hash.deep_symbolize_keys
-    end
-
-    def fieldset?(name)
-      params[name].present?
-    end
-
     def parse_fieldsets!
-      parse_fieldset!(:fields)
-      parse_fieldset!(:extra_fields)
-    end
-
-    def parse_fieldset!(name)
-      return unless params[name]
-
-      params[name].each_pair do |key, value|
-        params[name][key] = value.split(',').map(&:to_sym)
-      end
+      Util::FieldParams.parse!(params, :fields)
+      Util::FieldParams.parse!(params, :extra_fields)
     end
 
     # * Eager loads whitelisted includes
     # * Merges opts and ams_default_options
     def render_ams(scope, opts = {})
       scope = jsonapi_scope(scope) if scope.is_a?(ActiveRecord::Relation)
       options = default_ams_options
-      options[:include] = forced_includes || scrub_includes
+      options[:include] = forced_includes || Util::IncludeParams.scrub(self)
       options[:json] = scope
-      options[:fields] = fieldset(:fields) if fieldset?(:fields)
-      options[:extra_fields] = fieldset(:extra_fields) if fieldset?(:extra_fields)
+      options[:fields] = Util::FieldParams.fieldset(params, :fields) if params[:fields]
+      options[:extra_fields] = Util::FieldParams.fieldset(params, :extra_fields) if params[:extra_fields]
 
       options.merge!(opts)
       render(options)
@@ -211,5 +90,5 @@ def jsonapi(&blk)
         self._jsonapi_compliable = dsl
       end
     end
- end
+  end
 end

lib/jsonapi_compliable/dsl.rb

@@ -17,11 +17,11 @@ def initialize
     end
 
     def includes(whitelist: nil, &blk)
-      whitelist = parse_includes(whitelist) if whitelist
+      whitelist = JSONAPI::IncludeDirective.new(whitelist) if whitelist
 
       @sideloads = {
         whitelist: whitelist,
-        custom_function: blk
+        custom_scope: blk
       }
     end
 
@@ -56,48 +56,5 @@ def extra_field(field, &blk)
         proc: blk
       }
     end
-
-    def parse_includes(includes)
-      JSONAPI::IncludeDirective.new(includes)
-    end
-
-    def filter_scope(controller, scope, name, value)
-      name   = name.to_sym
-      filter = find_filter!(controller, name)
-      value  = value.split(',') if value.include?(',')
-
-      if custom_scope = filter.values.first[:filter]
-        custom_scope.call(scope, value)
-      else
-        scope.where(filter.keys.first => value)
-      end
-    end
-
-    def default_filter_scope(controller, scope)
-      @default_filters.each_pair do |name, opts|
-        next if find_filter(controller, name)
-        scope = opts[:filter].call(scope)
-      end
-
-      scope
-    end
-
-    private
-
-    def find_filter(controller, name)
-      find_filter!(controller, name)
-    rescue JSONAPICompliable::Errors::BadFilter
-      nil
-    end
-
-    def find_filter!(controller, name)
-      filter_name, filter_value = \
-        @filters.find { |_name, opts| opts[:aliases].include?(name.to_sym) }
-      raise JSONAPICompliable::Errors::BadFilter unless filter_name
-      if guard = filter_value[:if]
-        raise JSONAPICompliable::Errors::BadFilter if controller.send(guard) == false
-      end
-      { filter_name => filter_value }
-    end
   end
 end

lib/jsonapi_compliable/errors.rb

@@ -1,6 +1,15 @@
 module JSONAPICompliable
   module Errors
     class BadFilter < StandardError; end
-    class UnsupportedPageSize < StandardError; end
+
+    class UnsupportedPageSize < StandardError
+      def initialize(size, max)
+        @size, @max = size, max
+      end
+
+      def message
+        "Requested page size #{@size} is greater than max supported size #{@max}"
+      end
+    end
   end
 end

lib/jsonapi_compliable/scope/base.rb

@@ -0,0 +1,40 @@
+module JSONAPICompliable
+  module Scope
+    class Base
+      attr_reader :controller, :dsl, :params, :scope
+
+      def initialize(controller, scope)
+        @controller = controller
+        @dsl        = controller._jsonapi_compliable
+        @params     = controller.params
+        @scope      = scope
+      end
+
+      def apply
+        apply_standard_or_override
+      end
+
+      def apply_standard_or_override
+        if apply_standard_scope?
+          @scope = apply_standard_scope
+        else
+          @scope = apply_custom_scope
+        end
+
+        @scope
+      end
+
+      def apply_standard_scope?
+        custom_scope.nil?
+      end
+
+      def apply_standard_scope
+        raise 'override in subclass'
+      end
+
+      def apply_custom_scope
+        raise 'override in subclass'
+      end
+    end
+  end
+end

lib/jsonapi_compliable/scope/default_filter.rb

@@ -0,0 +1,14 @@
+module JSONAPICompliable
+  class Scope::DefaultFilter < Scope::Base
+    include Scope::Filterable
+
+    def apply
+      dsl.default_filters.each_pair do |name, opts|
+        next if find_filter(name)
+        @scope = opts[:filter].call(@scope)
+      end
+
+      @scope
+    end
+  end
+end

lib/jsonapi_compliable/scope/extra_fields.rb

@@ -0,0 +1,36 @@
+module JSONAPICompliable
+  class Scope::ExtraFields < Scope::Base
+
+    def apply
+      each_extra_field do |extra_field|
+        @scope = extra_field[:proc].call(@scope)
+      end
+
+      @scope
+    end
+
+    private
+
+    def each_extra_field
+      dsl.extra_fields.each_pair do |namespace, extra_fields|
+        extra_fields.each do |extra_field|
+          if requested_extra_field?(namespace, extra_field[:name])
+            yield extra_field
+          end
+        end
+      end
+    end
+
+    def extra_fields
+      params[:extra_fields] || {}
+    end
+
+    def requested_extra_field?(namespace, field)
+      if namespaced = extra_fields[namespace]
+        namespaced.include?(field)
+      else
+        false
+      end
+    end
+  end
+end