jsonapi_compliable 0.11.34 → 1.0.alpha.2

data/lib/jsonapi_compliable/resource/configuration.rb

@@ -0,0 +1,239 @@
+module JsonapiCompliable
+  class Resource
+    module Configuration
+      extend ActiveSupport::Concern
+
+      module Overrides
+        def serializer=(val)
+          if val
+            if super(Class.new(val))
+              apply_attributes_to_serializer
+              apply_sideloads_to_serializer
+            end
+          else
+            super
+          end
+        end
+
+        def polymorphic=(klasses)
+          super
+          send(:prepend, Polymorphism)
+        end
+
+        def type=(val)
+          if val = super
+            self.serializer.type(val)
+          end
+        end
+
+        def model
+          klass = super
+          unless klass || abstract_class?
+            if klass = infer_model
+              self.model = klass
+            else
+              raise Errors::ModelNotFound.new(self)
+            end
+          end
+          klass
+        end
+      end
+
+      included do
+        class << self
+          attr_writer :config
+        end
+
+        class_attribute :adapter,
+          :model,
+          :type,
+          :polymorphic,
+          :polymorphic_child,
+          :serializer,
+          :default_page_size,
+          :default_sort,
+          :attributes_readable_by_default,
+          :attributes_writable_by_default,
+          :attributes_sortable_by_default,
+          :attributes_filterable_by_default,
+          :relationships_readable_by_default,
+          :relationships_writable_by_default
+
+        class << self
+          prepend Overrides
+        end
+
+        def self.inherited(klass)
+          super
+          klass.config = Util::Hash.deep_dup(config)
+          klass.adapter ||= Adapters::Abstract.new
+          klass.default_sort ||= []
+          klass.default_page_size ||= 20
+          # re-assigning causes a new Class.new
+          if klass.serializer
+            klass.serializer = klass.serializer
+          else
+            klass.serializer = JSONAPI::Serializable::Resource
+          end
+          klass.type ||= klass.infer_type
+          default(klass, :attributes_readable_by_default, true)
+          default(klass, :attributes_writable_by_default, true)
+          default(klass, :attributes_sortable_by_default, true)
+          default(klass, :attributes_filterable_by_default, true)
+          default(klass, :relationships_readable_by_default, true)
+          default(klass, :relationships_writable_by_default, true)
+
+          unless klass.config[:attributes][:id]
+            klass.attribute :id, :integer_id
+          end
+          klass.stat total: [:count]
+        end
+      end
+
+      class_methods do
+        def get_attr!(name, flag, opts = {})
+          opts[:raise_error] = true
+          get_attr(name, flag, opts)
+        end
+
+        def get_attr(name, flag, opts = {})
+          defaults = { request: false }
+          opts = defaults.merge(opts)
+          new.get_attr(name, flag, opts)
+        end
+
+        def abstract_class?
+          !!abstract_class
+        end
+
+        def abstract_class
+          @abstract_class
+        end
+
+        def abstract_class=(val)
+          if @abstract_class = val
+            self.serializer = nil
+            self.type = nil
+          end
+        end
+
+        def infer_type
+          if name.present?
+            name.demodulize.gsub('Resource','').underscore.pluralize.to_sym
+          else
+            :undefined_jsonapi_type
+          end
+        end
+
+        def infer_model
+          name.gsub('Resource', '').safe_constantize if name
+        end
+
+        def default(object, attr, value)
+          prior = object.send(attr)
+          unless prior || prior == false
+            object.send(:"#{attr}=", value)
+          end
+        end
+        private :default
+
+        def config
+          @config ||=
+            {
+              filters: {},
+              default_filters: {},
+              stats: {},
+              sort_all: nil,
+              sorts: {},
+              pagination: nil,
+              before_commit: {},
+              attributes: {},
+              extra_attributes: {},
+              sideloads: {}
+            }
+        end
+
+        def attributes
+          config[:attributes]
+        end
+
+        def extra_attributes
+          config[:extra_attributes]
+        end
+
+        def all_attributes
+          attributes.merge(extra_attributes)
+        end
+
+        def sideloads
+          config[:sideloads]
+        end
+
+        def filters
+          config[:filters]
+        end
+
+        def sorts
+          config[:sorts]
+        end
+
+        def stats
+          config[:stats]
+        end
+
+        def pagination
+          config[:pagination]
+        end
+
+        def default_filters
+          config[:default_filters]
+        end
+      end
+
+      def get_attr!(name, flag, options = {})
+        options[:raise_error] = true
+        get_attr(name, flag, options)
+      end
+
+      def get_attr(name, flag, request: false, raise_error: false)
+        Util::AttributeCheck.run(self, name, flag, request, raise_error)
+      end
+
+      def filters
+        self.class.filters
+      end
+
+      def sort_all
+        self.class.sort_all
+      end
+
+      def sorts
+        self.class.sorts
+      end
+
+      def stats
+        self.class.stats
+      end
+
+      def pagination
+        self.class.pagination
+      end
+
+      def attributes
+        self.class.attributes
+      end
+
+      def extra_attributes
+        self.class.extra_attributes
+      end
+
+      def all_attributes
+        self.class.all_attributes
+      end
+
+      def default_filters
+        self.class.default_filters
+      end
+    end
+  end
+end

data/lib/jsonapi_compliable/resource/dsl.rb

@@ -0,0 +1,138 @@
+module JsonapiCompliable
+  class Resource
+    module DSL
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def filter(name, *args, &blk)
+          opts = args.extract_options!
+
+          if att = get_attr(name, :filterable, raise_error: :only_unsupported)
+            aliases = [name, opts[:aliases]].flatten.compact
+            operators = FilterOperators.build(&blk)
+            config[:filters][name.to_sym] = {
+              aliases: aliases,
+              type: att[:type]
+            }.merge(operators.to_hash)
+          else
+            if type = args[0]
+              attribute name, type, only: [:filterable]
+              filter(name, opts, &blk)
+            else
+              raise Errors::ImplicitFilterTypeMissing.new(self, name)
+            end
+          end
+        end
+
+        def sort_all(&blk)
+          if block_given?
+            config[:_sort_all] = blk
+          else
+            config[:_sort_all]
+          end
+        end
+
+        def sort(name, *args, &blk)
+          opts = args.extract_options!
+
+          if get_attr(name, :sortable, raise_error: :only_unsupported)
+            config[:sorts][name] = blk
+          else
+            if type = args[0]
+              attribute name, type, only: [:sortable]
+              sort(name, opts, &blk)
+            else
+              raise Errors::ImplicitSortTypeMissing.new(self, name)
+            end
+          end
+        end
+
+        def paginate(&blk)
+          config[:pagination] = blk
+        end
+
+        def stat(symbol_or_hash, &blk)
+          dsl = Stats::DSL.new(adapter, symbol_or_hash)
+          dsl.instance_eval(&blk) if blk
+          config[:stats][dsl.name] = dsl
+        end
+
+        def default_filter(name = nil, &blk)
+          name ||= :__default
+          config[:default_filters][name.to_sym] = {
+            filter: blk
+          }
+        end
+
+        def before_commit(only: [:create, :update, :destroy], &blk)
+          Array(only).each do |verb|
+            config[:before_commit][verb] = blk
+          end
+        end
+
+        def attribute(name, type, options = {}, &blk)
+          raise Errors::TypeNotFound.new(self, name, type) unless Types[type]
+          attribute_option(options, :readable)
+          attribute_option(options, :writable)
+          attribute_option(options, :sortable)
+          attribute_option(options, :filterable)
+          options[:type] = type
+          options[:proc] = blk
+          config[:attributes][name] = options
+          apply_attributes_to_serializer
+          filter(name) if options[:filterable]
+        end
+
+        def extra_attribute(name, type, options = {}, &blk)
+          raise Errors::TypeNotFound.new(self, name, type) unless Types[type]
+          defaults = {
+            type: type,
+            proc: blk,
+            readable: true,
+            writable: false,
+            sortable: false,
+            filterable: false
+          }
+          options = defaults.merge(options)
+          config[:extra_attributes][name] = options
+          apply_extra_attributes_to_serializer
+        end
+
+        def all_attributes
+          attributes.merge(extra_attributes)
+        end
+
+        def apply_attributes_to_serializer
+          serializer.type(type)
+          Util::SerializerAttributes.new(self, attributes).apply
+        end
+        private :apply_attributes_to_serializer
+
+        def apply_extra_attributes_to_serializer
+          Util::SerializerAttributes.new(self, extra_attributes, true).apply
+        end
+
+        def attribute_option(options, name)
+          if options[name] != false
+            default = if only = options[:only]
+                        Array(only).include?(name) ? true : false
+                      elsif except = options[:except]
+                        Array(except).include?(name) ? false : true
+                      else
+                        send(:"attributes_#{name}_by_default")
+                      end
+            options[name] ||= default
+          end
+        end
+        private :attribute_option
+
+       def relationship_option(options, name)
+          if options[name] != false
+            options[name] ||= send(:"relationships_#{name}_by_default")
+          end
+        end
+        private :attribute_option
+      end
+    end
+  end
+end

data/lib/jsonapi_compliable/resource/interface.rb

@@ -0,0 +1,32 @@
+module JsonapiCompliable
+  class Resource
+    module Interface
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def all(params = {}, base_scope = nil)
+          _all(params, {}, base_scope)
+        end
+
+        def _all(params, opts, base_scope)
+          runner = Runner.new(self, params)
+          runner.proxy(base_scope, opts)
+        end
+
+        def find(params, base_scope = nil)
+          id = params[:data].try(:[], :id) || params.delete(:id)
+          params[:filter] ||= {}
+          params[:filter].merge!(id: id)
+
+          runner = Runner.new(self, params)
+          runner.proxy(base_scope, single: true, raise_on_missing: true)
+        end
+
+        def build(params, base_scope = nil)
+          runner = Runner.new(self, params)
+          runner.proxy(base_scope, single: true, raise_on_missing: true)
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_compliable/resource/polymorphism.rb

@@ -0,0 +1,68 @@
+# For "Rails STI" behavior
+# CreditCard.all # => [<Visa>, <Mastercard>, etc]
+module JsonapiCompliable
+  class Resource
+    module Polymorphism
+      def self.prepended(klass)
+        klass.extend ClassMethods
+      end
+
+      def serializer_for(model)
+        if polymorphic_child?
+          serializer
+        else
+          child = self.class.resource_for_model(model)
+          child.serializer
+        end
+      end
+
+      def associate_all(parent, children, association_name, type)
+        children.each do |c|
+          associate(parent, c, association_name, type)
+        end
+      end
+
+      def associate(parent, child, association_name, type)
+        child_resource = self.class.resource_for_model(parent)
+        if child_resource.sideloads[association_name]
+          child_resource.adapter
+            .associate(parent, child, association_name, type)
+        end
+      end
+
+      module ClassMethods
+        def inherited(klass)
+          klass.type = nil
+          klass.model = klass.infer_model
+          klass.polymorphic_child = true
+          super
+        end
+
+        def sideload(name)
+          sl = super
+          if !polymorphic_child? && sl.nil?
+            children.each do |c|
+              break if sl = c.sideloads[name]
+            end
+          end
+          sl
+        end
+
+        def children
+          @children ||= polymorphic.map do |klass|
+            klass.is_a?(String) ? klass.safe_constantize : klass
+          end
+        end
+
+        def resource_for_model(model)
+          resource = children.find { |c| model.is_a?(c.model) }
+          if resource.nil?
+            raise Errors::PolymorphicChildNotFound.new(self, model)
+          else
+            resource
+          end
+        end
+      end
+    end
+  end
+end