jsonapi_compliable 0.4.0 → 0.5.1

data/lib/jsonapi_compliable/base.rb

@@ -6,65 +6,56 @@ module JsonapiCompliable
     MAX_PAGE_SIZE = 1_000
 
     included do
-      class_attribute :_jsonapi_compliable
-      attr_reader :_jsonapi_scope
+      class << self
+        attr_accessor :_jsonapi_compliable
+      end
 
-      before_action :parse_fieldsets!
-      after_action :reset_scope_flag
+      def self.inherited(klass)
+        super
+        klass._jsonapi_compliable = Class.new(_jsonapi_compliable)
+      end
     end
 
-    def default_page_number
-      1
+    def resource
+      @resource ||= self.class._jsonapi_compliable.new
     end
 
-    def default_page_size
-      20
+    def resource!
+      @resource = self.class._jsonapi_compliable.new
     end
 
-    def default_sort
-      'id'
+    def query
+      @query ||= Query.new(resource, params)
     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 query_hash
+      @query_hash ||= query.to_hash[resource.type]
     end
 
-    def reset_scope_flag
-      @_jsonapi_scope = nil
+    # TODO pass controller and action name here to guard
+    def wrap_context
+      if self.class._jsonapi_compliable
+        resource.with_context(self, action_name.to_sym) do
+          yield
+        end
+      end
     end
 
-    def parse_fieldsets!
-      Util::FieldParams.parse!(params, :fields)
-      Util::FieldParams.parse!(params, :extra_fields)
+    def jsonapi_scope(scope, opts = {})
+      resource.build_scope(scope, query, opts)
+    end
+
+    def perform_render_jsonapi(opts)
+      JSONAPI::Serializable::Renderer.render(opts.delete(:jsonapi), opts)
     end
 
     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[:meta] ||= {}
-      options.merge!(opts)
-      options[:meta][:stats] = Stats::Payload.new(self, scoped).generate if params[:stats]
-      options[:expose] ||= {}
-      options[:expose][:context] = self
-      options[:expose][:extra_fields] = Util::FieldParams.fieldset(params, :extra_fields) if params[:extra_fields]
-
-      render(options)
+      scope = jsonapi_scope(scope) unless opts[:scope] == false || scope.is_a?(JsonapiCompliable::Scope)
+      opts  = default_jsonapi_render_options.merge(opts)
+      opts  = Util::RenderOptions.generate(scope, query_hash, opts)
+      opts[:expose][:context] = self
+      opts[:include] = forced_includes if force_includes?
+      perform_render_jsonapi(opts)
     end
 
     # render_jsonapi(foo) equivalent to
@@ -74,11 +65,11 @@ module JsonapiCompliable
       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
     def forced_includes(data = nil)
-      return unless force_includes?
       data = raw_params[:data] unless data
 
       {}.tap do |forced|
@@ -95,21 +86,23 @@ module JsonapiCompliable
       end
     end
 
+    # Legacy
     def force_includes?
       %w(PUT PATCH POST).include?(request.method) and
         raw_params.try(:[], :data).try(:[], :relationships).present?
     end
 
     module ClassMethods
-      def jsonapi(&blk)
-        if !self._jsonapi_compliable
-          dsl = JsonapiCompliable::DSL.new
-          self._jsonapi_compliable = dsl
+      def jsonapi(resource: nil, &blk)
+        if resource
+          self._jsonapi_compliable = resource
         else
-          self._jsonapi_compliable = self._jsonapi_compliable.copy
+          if !self._jsonapi_compliable
+            self._jsonapi_compliable = Class.new(JsonapiCompliable::Resource)
+          end
         end
 
-        self._jsonapi_compliable.instance_eval(&blk)
+        self._jsonapi_compliable.class_eval(&blk) if blk
       end
     end
   end

data/lib/jsonapi_compliable/deserializable.rb

@@ -113,10 +113,15 @@ module JsonapiCompliable
 
     def deserialize_jsonapi!
       self.raw_params = self.params.deep_dup
-      hash = params.to_unsafe_h
-      hash = hash.with_indifferent_access if Rails::VERSION::MAJOR == 4
-      deserialized = Deserialization.new(hash).deserialize
-      self.params = ActionController::Parameters.new(deserialized)
+
+      if defined?(::Rails) && (is_a?(ActionController::Base) || (defined?(ActionController::API) && is_a?(ActionController::API)))
+        hash = params.to_unsafe_h
+        hash = hash.with_indifferent_access if ::Rails::VERSION::MAJOR == 4
+        deserialized = Deserialization.new(hash).deserialize
+        self.params = ActionController::Parameters.new(deserialized)
+      else
+        self.params =  Deserialization.new(params).deserialize
+      end
     end
   end
 end

data/lib/jsonapi_compliable/extensions/extra_attribute.rb

@@ -14,11 +14,7 @@ module JsonapiCompliable
               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[@_type] && @extra_fields[@_type].include?(name)
           }
 
           attribute name, if: allow_field, &blk

data/lib/jsonapi_compliable/query.rb

@@ -0,0 +1,153 @@
+# TODO: refactor - code could be better but it's a one-time thing.
+
+module JsonapiCompliable
+  class Query
+    attr_reader :params, :resource
+
+    def self.default_hash
+      {
+        filter: {},
+        sort: [],
+        page: {},
+        include: {},
+        stats: {},
+        fields: {},
+        extra_fields: {}
+      }
+    end
+
+    def initialize(resource, params)
+      @resource = resource
+      @params = params
+    end
+
+    def include_directive
+      @include_directive ||= JSONAPI::IncludeDirective.new(params[:include])
+    end
+
+    def include_hash
+      @include_hash ||= include_directive.to_hash
+    end
+
+    def all_requested_association_names
+      @all_requested_association_names ||= Util::Hash.keys(include_hash)
+    end
+
+    def to_hash
+      hash = { resource.type => self.class.default_hash }
+
+      all_requested_association_names.each do |name|
+        hash[name] = self.class.default_hash
+      end
+
+      fields = parse_fields({}, :fields)
+      extra_fields = parse_fields({}, :extra_fields)
+      hash.each_pair do |type, query_hash|
+        hash[type][:fields] = fields
+        hash[type][:extra_fields] = extra_fields
+      end
+
+      parse_filter(hash)
+      parse_sort(hash)
+      parse_pagination(hash)
+      parse_include(hash, include_hash)
+      parse_stats(hash)
+
+      hash
+    end
+
+    def zero_results?
+      !@params[:page].nil? &&
+        !@params[:page][:size].nil? &&
+        @params[:page][:size].to_i == 0
+    end
+
+    private
+
+    def association?(name)
+      resource.association_names.include?(name)
+    end
+
+    def parse_include(memo, incl_hash, namespace = nil)
+      namespace ||= resource.type
+
+      memo[namespace][:include] = incl_hash
+      incl_hash.each_pair do |key, sub_hash|
+        memo[key][:include] = parse_include(memo, sub_hash, key)
+      end
+    end
+
+    def parse_stats(hash)
+      if params[:stats]
+        params[:stats].each_pair do |namespace, calculations|
+          if namespace == resource.type || association?(namespace)
+            calculations.each_pair do |name, calcs|
+              hash[namespace][:stats][name] = calcs.split(',').map(&:to_sym)
+            end
+          else
+            hash[resource.type][:stats][namespace] = calculations.split(',').map(&:to_sym)
+          end
+        end
+      end
+    end
+
+    def parse_fields(hash, type)
+      field_params = Util::FieldParams.parse(params[type])
+      hash[type] = field_params
+    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[resource.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[resource.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[resource.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

data/lib/jsonapi_compliable/rails.rb

@@ -0,0 +1,14 @@
+require 'jsonapi/rails'
+
+module JsonapiCompliable
+  module Rails
+    def self.included(klass)
+      klass.send(:include, Base)
+
+      klass.class_eval do
+        around_action :wrap_context
+        alias_method :perform_render_jsonapi, :render
+      end
+    end
+  end
+end

data/lib/jsonapi_compliable/resource.rb

@@ -0,0 +1,191 @@
+module JsonapiCompliable
+  class Resource
+    attr_reader :filters,
+      :default_filters,
+      :default_sort,
+      :default_page_size,
+      :default_page_number,
+      :sorting,
+      :stats,
+      :sideload_whitelist,
+      :pagination,
+      :extra_fields,
+      :sideloading,
+      :adapter,
+      :type,
+      :context
+
+    class << self
+      attr_accessor :config
+    end
+
+    delegate :sideload, to: :sideloading
+
+    # Incorporate custom adapter methods
+    def self.method_missing(meth, *args, &blk)
+      if sideloading.respond_to?(meth)
+        sideloading.send(meth, *args, &blk)
+      else
+        super
+      end
+    end
+
+    def self.inherited(klass)
+      klass.config = self.config.deep_dup
+    end
+
+    def self.sideloading
+      config[:sideloading] ||= Sideload.new(:base, resource: self)
+    end
+
+    def self.sideload_whitelist(whitelist)
+      config[:sideload_whitelist] = JSONAPI::IncludeDirective.new(whitelist).to_hash
+    end
+
+    def self.allow_filter(name, *args, &blk)
+      opts = args.extract_options!
+      aliases = [name, opts[:aliases]].flatten.compact
+      config[:filters][name.to_sym] = {
+        aliases: aliases,
+        if: opts[:if],
+        filter: blk
+      }
+    end
+
+    def self.allow_stat(symbol_or_hash, &blk)
+      dsl = Stats::DSL.new(config[:adapter], symbol_or_hash)
+      dsl.instance_eval(&blk) if blk
+      config[:stats][dsl.name] = dsl
+    end
+
+    def self.default_filter(name, &blk)
+      config[:default_filters][name.to_sym] = {
+        filter: blk
+      }
+    end
+
+    def self.sort(&blk)
+      config[:sorting] = blk
+    end
+
+    def self.paginate(&blk)
+      config[:pagination] = blk
+    end
+
+    def self.extra_field(name, &blk)
+      config[:extra_fields][name] = blk
+    end
+
+    def self.use_adapter(klass)
+      config[:adapter] = klass.new
+    end
+
+    def self.default_sort(val)
+      config[:default_sort] = val
+    end
+
+    def self.type(value = nil)
+      config[:type] = value
+    end
+
+    def self.default_page_number(val)
+      config[:default_page_number] = val
+    end
+
+    def self.default_page_size(val)
+      config[:default_page_size] = val
+    end
+
+    def self.config
+      @config ||= begin
+        {
+          sideload_whitelist: {},
+          filters: {},
+          default_filters: {},
+          extra_fields: {},
+          stats: {},
+          sorting: nil,
+          pagination: nil,
+          adapter: Adapters::Abstract.new
+        }
+      end
+    end
+
+    def copy
+      self.class.new(@config.deep_dup)
+    end
+
+    def initialize(config = nil)
+      config = config || self.class.config.deep_dup
+      set_config(config)
+    end
+
+    def set_config(config)
+      @config = config
+      config.each_pair do |key, value|
+        instance_variable_set(:"@#{key}", value)
+      end
+    end
+
+    def with_context(object, namespace = nil)
+      begin
+        prior = context
+        @context = { object: object, namespace: namespace }
+        yield
+      ensure
+        @context = prior
+      end
+    end
+
+    def context
+      @context || {}
+    end
+
+    def build_scope(base, query, opts = {})
+      Scope.new(base, self, query, opts)
+    end
+
+    def association_names
+      @association_names ||= begin
+        if sideloading
+          Util::Hash.keys(sideloading.to_hash[:base])
+        else
+          []
+        end
+      end
+    end
+
+    def allowed_sideloads(namespace = nil)
+      return {} unless sideloading
+
+      namespace ||= context[:namespace]
+      sideloads = sideloading.to_hash[:base]
+      if !sideload_whitelist.empty? && namespace
+        sideloads = Util::IncludeParams.scrub(sideloads, sideload_whitelist[namespace])
+      end
+      sideloads
+    end
+
+    def stat(attribute, calculation)
+      stats_dsl = stats[attribute] || stats[attribute.to_sym]
+      raise Errors::StatNotFound.new(attribute, calculation) unless stats_dsl
+      stats_dsl.calculation(calculation)
+    end
+
+    def default_sort
+      @default_sort || [{ id: :asc }]
+    end
+
+    def default_page_number
+      @default_page_number || 1
+    end
+
+    def default_page_size
+      @default_page_size || 20
+    end
+
+    def type
+      @type || :undefined_jsonapi_type
+    end
+  end
+end

data/lib/jsonapi_compliable/scope.rb

@@ -0,0 +1,57 @@
+module JsonapiCompliable
+  class Scope
+    def initialize(object, resource, query, opts = {})
+      @object    = object
+      @resource  = resource
+      @query     = query
+
+      # Namespace for the 'outer' or 'main' resource is its type
+      # For its relationships, its the relationship name
+      # IOW when hitting /states, it's resource type 'states
+      # when hitting /authors?include=state its 'state'
+      @namespace = opts.delete(:namespace) || resource.type
+
+      apply_scoping(opts)
+    end
+
+    def resolve_stats
+      Stats::Payload.new(@resource, query_hash, @unpaginated_object).generate
+    end
+
+    def resolve
+      if @query.zero_results?
+        []
+      else
+        resolved = @object
+        # TODO - configurable resolve function
+        resolved = @object.to_a if @object.is_a?(ActiveRecord::Relation)
+        sideload(resolved, query_hash[:include]) if query_hash[:include]
+        resolved
+      end
+    end
+
+    def query_hash
+      @query_hash ||= @query.to_hash[@namespace]
+    end
+
+    private
+
+    def sideload(results, includes)
+      includes.each_pair do |name, nested|
+        if @resource.allowed_sideloads.has_key?(name)
+          sideload = @resource.sideload(name)
+          sideload.resolve(results, @query)
+        end
+      end
+    end
+
+    def apply_scoping(opts)
+      @object = JsonapiCompliable::Scoping::DefaultFilter.new(@resource, query_hash, @object).apply
+      @object = JsonapiCompliable::Scoping::Filter.new(@resource, query_hash, @object).apply unless opts[:filter] == false
+      @object = JsonapiCompliable::Scoping::ExtraFields.new(@resource, query_hash, @object).apply unless opts[:extra_fields] == false
+      @object = JsonapiCompliable::Scoping::Sort.new(@resource, query_hash, @object).apply unless opts[:sort] == false
+      @unpaginated_object = @object
+      @object = JsonapiCompliable::Scoping::Paginate.new(@resource, query_hash, @object).apply unless opts[:paginate] == false
+    end
+  end
+end

data/lib/jsonapi_compliable/{scope → scoping}/base.rb

@@ -1,12 +1,11 @@
 module JsonapiCompliable
-  module Scope
+  module Scoping
     class Base
-      attr_reader :controller, :dsl, :params, :scope
+      attr_reader :resource, :query_hash
 
-      def initialize(controller, scope)
-        @controller = controller
-        @dsl        = controller._jsonapi_compliable
-        @params     = controller.params
+      def initialize(resource, query_hash, scope)
+        @query_hash = query_hash
+        @resource   = resource
         @scope      = scope
       end
 

data/lib/jsonapi_compliable/{scope → scoping}/default_filter.rb

@@ -1,9 +1,9 @@
 module JsonapiCompliable
-  class Scope::DefaultFilter < Scope::Base
-    include Scope::Filterable
+  class Scoping::DefaultFilter < Scoping::Base
+    include Scoping::Filterable
 
     def apply
-      dsl.default_filters.each_pair do |name, opts|
+      resource.default_filters.each_pair do |name, opts|
         next if overridden?(name)
         @scope = opts[:filter].call(@scope)
       end

data/lib/jsonapi_compliable/scoping/extra_fields.rb

@@ -0,0 +1,25 @@
+module JsonapiCompliable
+  class Scoping::ExtraFields < Scoping::Base
+    def apply
+      each_extra_field do |callable|
+        @scope = callable.call(@scope)
+      end
+
+      @scope
+    end
+
+    private
+
+    def each_extra_field
+      resource.extra_fields.each_pair do |name, callable|
+        if extra_fields.include?(name)
+          yield callable
+        end
+      end
+    end
+
+    def extra_fields
+      query_hash[:extra_fields][resource.type] || []
+    end
+  end
+end

data/lib/jsonapi_compliable/{scope → scoping}/filter.rb

@@ -1,6 +1,6 @@
 module JsonapiCompliable
-  class Scope::Filter < Scope::Base
-    include Scope::Filterable
+  class Scoping::Filter < Scoping::Base
+    include Scoping::Filterable
 
     def apply
       each_filter do |filter, value|
@@ -14,7 +14,7 @@ module JsonapiCompliable
       if custom_scope = filter.values.first[:filter]
         custom_scope.call(@scope, value)
       else
-        @scope.where(filter.keys.first => value)
+        resource.adapter.filter(@scope, filter.keys.first, value)
       end
     end
 
@@ -24,7 +24,7 @@ module JsonapiCompliable
       filter_param.each_pair do |param_name, param_value|
         filter = find_filter!(param_name.to_sym)
         value  = param_value
-        value  = value.split(',') if value.include?(',')
+        value  = value.split(',') if value.is_a?(String) && value.include?(',')
         yield filter, value
       end
     end