jsonapi_compliable 0.11.34 → 1.0.alpha.2

data/lib/generators/jsonapi/templates/resource_writes_spec.rb.erb

@@ -0,0 +1,63 @@
+require 'rails_helper'
+
+RSpec.describe <%= resource_klass %>, type: :resource do
+  describe 'creating' do
+    let(:payload) do
+      {
+        data: {
+          type: '<%= file_name.pluralize %>',
+          attributes: { }
+        }
+      }
+    end
+
+    let(:instance) do
+      <%= resource_klass %>.build(payload)
+    end
+
+    it 'works' do
+      expect {
+        expect(instance.save).to eq(true)
+      }.to change { <%= model_klass %>.count }.by(1)
+    end
+  end
+
+  describe 'updating' do
+    let!(:<%= file_name %>) { create(:<%= file_name %>) }
+
+    let(:payload) do
+      {
+        data: {
+          id: <%= file_name %>.id.to_s,
+          type: '<%= file_name.pluralize %>',
+          attributes: { } # Todo!
+        }
+      }
+    end
+
+    let(:instance) do
+      <%= resource_klass %>.find(payload)
+    end
+
+    xit 'works (add some attributes and enable this spec)' do
+      expect {
+        expect(instance.update_attributes).to eq(true)
+      }.to change { <%= file_name %>.reload.updated_at }
+      # and change { instance.foo }.to('bar') <- example
+    end
+  end
+
+  describe 'destroying' do
+    let!(:<%= file_name %>) { create(:<%= file_name %>) }
+
+    let(:instance) do
+      <%= resource_klass %>.find(id: <%= file_name %>.id)
+    end
+
+    it 'works' do
+      expect {
+        expect(instance.destroy).to eq(true)
+      }.to change { <%= model_klass %>.count }.by(-1)
+    end
+  end
+end

data/lib/jsonapi_compliable.rb

@@ -1,20 +1,88 @@
+require 'json'
+require 'forwardable'
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/hash/conversions' # to_xml
+require 'active_support/concern'
+require 'active_support/time'
+
+require 'dry-types'
+require 'jsonapi_errorable'
+
+require 'jsonapi/serializable'
+# Temporary fix until fixed upstream
+# https://github.com/jsonapi-rb/jsonapi-serializable/pull/102
+JSONAPI::Serializable::Resource.class_eval do
+  def requested_relationships(fields)
+    @_relationships
+  end
+end
+
+# This library looks up a serializer based on the record's class name
+# This wouldn't work for us, since a model may be associated with
+# multiple resources.
+# Instead, this variable is assigned when the query is resolved
+# To ensure we always render with the *resource* serializer
+JSONAPI::Serializable::Renderer.class_eval do
+  def _build(object, exposures, klass)
+    klass = object.instance_variable_get(:@__serializer_klass)
+    klass.new(exposures.merge(object: object))
+  end
+end
+
+# See above comment
+JSONAPI::Serializable::Relationship.class_eval do
+  def data
+    @_resources_block = proc do
+      resources = yield
+      if resources.nil?
+        nil
+      elsif resources.respond_to?(:to_ary)
+        Array(resources).map do |obj|
+          klass = obj.instance_variable_get(:@__serializer_klass)
+          klass.new(@_exposures.merge(object: obj))
+        end
+      else
+        klass = resources.instance_variable_get(:@__serializer_klass)
+        klass.new(@_exposures.merge(object: resources))
+      end
+    end
+  end
+end
+
 require "jsonapi_compliable/version"
 require "jsonapi_compliable/configuration"
+require "jsonapi_compliable/context"
 require "jsonapi_compliable/errors"
+require "jsonapi_compliable/types"
+require "jsonapi_compliable/adapters/abstract"
+require "jsonapi_compliable/resource/sideloading"
+require "jsonapi_compliable/resource/configuration"
+require "jsonapi_compliable/resource/dsl"
+require "jsonapi_compliable/resource/interface"
+require "jsonapi_compliable/resource/polymorphism"
+require "jsonapi_compliable/sideload"
+require "jsonapi_compliable/sideload/has_many"
+require "jsonapi_compliable/sideload/belongs_to"
+require "jsonapi_compliable/sideload/has_one"
+require "jsonapi_compliable/sideload/many_to_many"
+require "jsonapi_compliable/sideload/polymorphic_belongs_to"
 require "jsonapi_compliable/resource"
+require "jsonapi_compliable/resource_proxy"
 require "jsonapi_compliable/query"
-require "jsonapi_compliable/sideload"
 require "jsonapi_compliable/scope"
 require "jsonapi_compliable/deserializer"
+require "jsonapi_compliable/renderer"
+require "jsonapi_compliable/hash_renderer"
+require "jsonapi_compliable/filter_operators"
 require "jsonapi_compliable/scoping/base"
 require "jsonapi_compliable/scoping/sort"
 require "jsonapi_compliable/scoping/paginate"
-require "jsonapi_compliable/scoping/extra_fields"
+require "jsonapi_compliable/scoping/extra_attributes"
 require "jsonapi_compliable/scoping/filterable"
 require "jsonapi_compliable/scoping/default_filter"
 require "jsonapi_compliable/scoping/filter"
 require "jsonapi_compliable/util/render_options"
-require "jsonapi_compliable/adapters/abstract"
 require "jsonapi_compliable/stats/dsl"
 require "jsonapi_compliable/stats/payload"
 require "jsonapi_compliable/util/include_params"
@@ -25,26 +93,25 @@ require "jsonapi_compliable/util/persistence"
 require "jsonapi_compliable/util/validation_response"
 require "jsonapi_compliable/util/sideload"
 require "jsonapi_compliable/util/hooks"
+require "jsonapi_compliable/util/attribute_check"
+require "jsonapi_compliable/util/serializer_attributes"
 
-# require correct jsonapi-rb before extensions
-if defined?(Rails)
-  require 'jsonapi_compliable/rails'
-else
-  require 'jsonapi/serializable'
-end
-
-# Temporary fix until fixed upstream
-# https://github.com/jsonapi-rb/jsonapi-serializable/pull/102
-JSONAPI::Serializable::Resource.class_eval do
-  def requested_relationships(fields)
-    @_relationships
-  end
-end
+require 'jsonapi_compliable/adapters/null'
 
 require "jsonapi_compliable/extensions/extra_attribute"
 require "jsonapi_compliable/extensions/boolean_attribute"
 require "jsonapi_compliable/extensions/temp_id"
 
+if defined?(ActiveRecord)
+  require 'jsonapi_compliable/adapters/active_record'
+end
+
+if defined?(Rails)
+  require 'jsonapi_compliable/railtie'
+  require 'jsonapi_compliable/rails'
+  require 'jsonapi_compliable/responders'
+end
+
 module JsonapiCompliable
   autoload :Base, 'jsonapi_compliable/base'
 
@@ -65,7 +132,7 @@ module JsonapiCompliable
   end
 
   # @api private
-  def self.with_context(obj, namespace)
+  def self.with_context(obj, namespace = nil)
     begin
       prior = self.context
       self.context = { object: obj, namespace: namespace }
@@ -89,3 +156,5 @@ module JsonapiCompliable
     yield config
   end
 end
+
+require "jsonapi_compliable/runner"

data/lib/jsonapi_compliable/adapters/abstract.rb

@@ -76,17 +76,184 @@ module JsonapiCompliable
     # @see Adapters::ActiveRecordSideloading
     # @see Adapters::Null
     class Abstract
-      # @param scope The scope object we are chaining
-      # @param [Symbol] attribute The attribute name we are filtering
-      # @param value The corresponding query parameter value
-      # @return the scope
-      #
-      # @example ActiveRecord default
-      #   def filter(scope, attribute, value)
-      #     scope.where(attribute => value)
-      #   end
-      def filter(scope, attribute, value)
-        raise 'you must override #filter in an adapter subclass'
+      def filter_string_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_string_eq)
+      end
+
+      def filter_string_eql(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_string_eql)
+      end
+
+      def filter_string_not_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_string_not_eq)
+      end
+
+      def filter_string_not_eql(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_string_not_eql)
+      end
+
+      def filter_string_prefix(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_string_prefix)
+      end
+
+      def filter_string_not_prefix(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_string_not_prefix)
+      end
+
+      def filter_string_suffix(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_string_suffix)
+      end
+
+      def filter_string_not_suffix(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_string_not_suffix)
+      end
+
+      def filter_string_like(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_string_like)
+      end
+
+      def filter_string_not_like(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_string_not_like)
+      end
+
+      def filter_integer_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_integer_eq)
+      end
+
+      def filter_integer_not_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_integer_not_eq)
+      end
+
+      def filter_integer_gt(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_integer_gt)
+      end
+
+      def filter_integer_gte(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_integer_gte)
+      end
+
+      def filter_integer_lt(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_integer_lt)
+      end
+
+      def filter_integer_lte(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_integer_lte)
+      end
+
+      def filter_datetime_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_eq)
+      end
+
+      def filter_datetime_not_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_not_eq)
+      end
+
+      def filter_datetime_lte(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_lte)
+      end
+
+      def filter_float_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_float_eq)
+      end
+
+      def filter_float_not_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_float_not_eq)
+      end
+
+      def filter_float_gt(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_float_gt)
+      end
+
+      def filter_float_gte(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_float_gte)
+      end
+
+      def filter_float_lt(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_float_lt)
+      end
+
+      def filter_float_lte(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_float_lte)
+      end
+
+      def filter_decimal_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_decimal_eq)
+      end
+
+      def filter_decimal_not_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_decimal_not_eq)
+      end
+
+      def filter_decimal_gt(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_decimal_gt)
+      end
+
+      def filter_decimal_gte(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_decimal_gte)
+      end
+
+      def filter_decimal_lt(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_decimal_lt)
+      end
+
+      def filter_decimal_lte(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_decimal_lte)
+      end
+
+      def filter_datetime_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_eq)
+      end
+
+      def filter_datetime_not_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_not_eq)
+      end
+
+      def filter_datetime_gt(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_gt)
+      end
+
+      def filter_datetime_gte(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_gte)
+      end
+
+      def filter_datetime_lt(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_lt)
+      end
+
+      def filter_datetime_lte(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_lte)
+      end
+
+      def filter_date_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_date_eq)
+      end
+
+      def filter_date_not_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_date_not_eq)
+      end
+
+      def filter_date_gt(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_date_gt)
+      end
+
+      def filter_date_gte(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_date_gte)
+      end
+
+      def filter_date_lt(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_date_lt)
+      end
+
+      def filter_date_lte(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_date_lte)
+      end
+
+      def filter_boolean_eq(scope, attribute, value)
+        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_boolean_eq)
+      end
+
+      def base_scope(model)
+        raise 'you must override #base_scope in an adapter subclass'
       end
 
       # @param scope The scope object we are chaining
@@ -211,30 +378,19 @@ module JsonapiCompliable
         scope
       end
 
-      # Assign these two objects together.
-      #
-      # @example Basic accessor
-      #   def associate(parent, child, association_name, association_type)
-      #     if association_type == :has_many
-      #       parent.send(association_name).push(child)
-      #     else
-      #       child.send(:"#{association_name}=", parent)
-      #     end
-      #   end
-      #
-      # +association_name+ and +association_type+ come from your sideload
-      # configuration:
-      #
-      #   allow_sideload :the_name, type: the_type do
-      #     # ... code.
-      #   end
-      #
-      # @param parent The parent object (via the JSONAPI 'relationships' graph)
-      # @param child The child object (via the JSONAPI 'relationships' graph)
-      # @param association_name The 'relationships' key we are processing
-      # @param association_type The Sideload type (see Sideload#type). Usually :has_many/:belongs_to/etc
+      def associate_all(parent, children, association_name, association_type)
+        children.each do |c|
+          associate(parent, c, association_name, association_type)
+        end
+      end
+
+      # Probably want to override
       def associate(parent, child, association_name, association_type)
-        raise 'you must override #associate in an adapter subclass'
+        if [:has_many, :many_to_many].include?(association_type)
+          parent.send(:"#{association_name}") << child
+        else
+          parent.send(:"#{association_name}=", child)
+        end
       end
 
       # Remove the association without destroying objects
@@ -277,17 +433,18 @@ module JsonapiCompliable
         raise 'you must override #disassociate in an adapter subclass'
       end
 
-      # This module gets mixed in to Sideload classes
-      # This is where you define methods like has_many,
-      # belongs_to etc that wrap the lower-level Sideload#allow_sideload
-      #
-      # @see Resource#allow_sideload
-      # @see Sideload#allow_sideload
-      # @see Adapters::ActiveRecord#sideloading_module
-      # @see Adapters::ActiveRecordSideloading
-      # @return the module to mix in
-      def sideloading_module
-        Module.new
+      # You want to override this!
+      # Map of association_type => sideload_class
+      # e.g.
+      # { has_many: Adapters::ActiveRecord::HasManySideload }
+      def sideloading_classes
+        {
+          has_many: ::JsonapiCompliable::Sideload::HasMany,
+          belongs_to: ::JsonapiCompliable::Sideload::BelongsTo,
+          has_one: ::JsonapiCompliable::Sideload::HasOne,
+          many_to_many: ::JsonapiCompliable::Sideload::ManyToMany,
+          polymorphic_belongs_to: ::JsonapiCompliable::Sideload::PolymorphicBelongsTo
+        }
       end
 
       # @param [Class] model_class The configured model class (see Resource.model)