jsonapi_compliable 0.7.9 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 725d1d0d6d2f31535a981d6894f6f49fa4d59686
-  data.tar.gz: 04d9c2419e99b379cb2884eaaf63f3f022bb8e9e
+  metadata.gz: 10190f5b7e0cd15456e21552f847b9a41d5fae80
+  data.tar.gz: 002b8c3ffb2fe962e682182199519a8182a909a0
 SHA512:
-  metadata.gz: 8b2ac3294051a12d5fc84e508be50a6d8b890109ef253e27ac975ed545e649e007b1035e8a6ff2c7da58861a0c27e5ade4f96a90c07564649ea084783d058dfc
-  data.tar.gz: afef6fafdc7ef0a4b4b36ad3c2ad0f0d8c23286c55dd61b20bec29688e2e3b1d7c3bbb9ff4ead5d3c3f1aeb7637682bb66cfe1d7a5a0bfadf9147fa752b39ebc
+  metadata.gz: 5744a2c7eba2af24ea476210cf9804fdbc16d0c636b6e9d55c586e198a6ddf196122f8e6e27029d7f723cd07670efbea3d6aa21d4368ece68152c212249dd0ca
+  data.tar.gz: dbae4b77df449427b11d0dd5135a722b713a11c8f7fd05d62192dbd13c043ce48fcd3517179fb72afef9a05d460aadc6a4137fda0ef200f1bd1b6f9a99eca2c8

data/lib/jsonapi_compliable/adapters/abstract.rb

@@ -237,6 +237,46 @@ module JsonapiCompliable
         raise 'you must override #associate in an adapter subclass'
       end
 
+      # Remove the association without destroying objects
+      #
+      # This is NOT needed in the standard use case. The standard use case would be:
+      #
+      #   def update(attrs)
+      #     # attrs[:the_foreign_key] is nil, so updating the record disassociates
+      #   end
+      #
+      # However, sometimes you need side-effect or elsewise non-standard behavior. Consider
+      # using {{https://github.com/mbleigh/acts-as-taggable-on acts_as_taggable_on}} gem:
+      #
+      #   # Not actually needed, just an example
+      #   def disassociate(parent, child, association_name, association_type)
+      #     parent.tag_list.remove(child.name)
+      #   end
+      #
+      # @example Basic accessor
+      #   def disassociate(parent, child, association_name, association_type)
+      #     if association_type == :has_many
+      #       parent.send(association_name).delete(child)
+      #     else
+      #       child.send(:"#{association_name}=", nil)
+      #     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 disassociate(parent, child, association_name, association_type)
+        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

data/lib/jsonapi_compliable/adapters/active_record.rb

@@ -75,11 +75,24 @@ module JsonapiCompliable
         if association_type == :has_many
           parent.association(association_name).loaded!
           parent.association(association_name).add_to_target(child, :skip_callbacks)
+        elsif association_type == :habtm
+          parent.send(association_name) << child
         else
           child.send("#{association_name}=", parent)
         end
       end
 
+      # When a has_and_belongs_to_many relationship, we don't have a foreign
+      # key that can be null'd. Instead, go through the ActiveRecord API.
+      # @see Adapters::Abstract#disassociate
+      def disassociate(parent, child, association_name, association_type)
+        if association_type == :habtm
+          parent.send(association_name).delete(child)
+        else
+          # Nothing to do here, happened when we merged foreign key
+        end
+      end
+
       # (see Adapters::Abstract#create)
       def create(model_class, create_params)
         instance = model_class.new(create_params)

data/lib/jsonapi_compliable/resource.rb

@@ -543,10 +543,28 @@ module JsonapiCompliable
       adapter.destroy(model, id)
     end
 
+    # Delegates #associate to adapter. Built for overriding.
+    #
+    # @see .use_adapter
+    # @see Adapters::Abstract#associate
+    # @see Adapters::ActiveRecord#associate
+    def associate(parent, child, association_name, type)
+      adapter.associate(parent, child, association_name, type)
+    end
+
+    # Delegates #disassociate to adapter. Built for overriding.
+    #
+    # @see .use_adapter
+    # @see Adapters::Abstract#disassociate
+    # @see Adapters::ActiveRecord#disassociate
+    def disassociate(parent, child, association_name, type)
+      adapter.disassociate(parent, child, association_name, type)
+    end
+
     # @api private
-    def persist_with_relationships(meta, attributes, relationships)
+    def persist_with_relationships(meta, attributes, relationships, caller_model = nil)
       persistence = JsonapiCompliable::Util::Persistence \
-        .new(self, meta, attributes, relationships)
+        .new(self, meta, attributes, relationships, caller_model)
       persistence.run
     end
 

data/lib/jsonapi_compliable/sideload.rb

@@ -170,24 +170,25 @@ module JsonapiCompliable
     end
 
     # Configure how to associate parent and child records.
-    #
-    # @example Basic attr_accessor
-    #   def associate(parent, child)
-    #     if type == :has_many
-    #       parent.send(:"#{name}").push(child)
-    #     else
-    #       child.send(:"#{name}=", parent)
-    #     end
-    #   end
+    # Delegates to #resource
     #
     # @see #name
     # @see #type
+    # @api private
     def associate(parent, child)
       association_name = @parent ? @parent.name : name
-      resource_class.config[:adapter].associate parent,
-        child,
-        association_name,
-        type
+      resource.associate(parent, child, association_name, type)
+    end
+
+    # Configure how to disassociate parent and child records.
+    # Delegates to #resource
+    #
+    # @see #name
+    # @see #type
+    # @api private
+    def disassociate(parent, child)
+      association_name = @parent ? @parent.name : name
+      resource.disassociate(parent, child, association_name, type)
     end
 
     # Define an attribute that groups the parent records. For instance, with

data/lib/jsonapi_compliable/util/persistence.rb

@@ -5,11 +5,12 @@ class JsonapiCompliable::Util::Persistence
   # @param [Hash] meta see (Deserializer#meta)
   # @param [Hash] attributes see (Deserializer#attributes)
   # @param [Hash] relationships see (Deserializer#relationships)
-  def initialize(resource, meta, attributes, relationships)
+  def initialize(resource, meta, attributes, relationships, caller_model)
     @resource      = resource
     @meta          = meta
     @attributes    = attributes
     @relationships = relationships
+    @caller_model  = caller_model
   end
 
   # Perform the actual save logic.
@@ -37,7 +38,7 @@ class JsonapiCompliable::Util::Persistence
     assign_temp_id(persisted, @meta[:temp_id])
     associate_parents(persisted, parents)
 
-    children = process_has_many(@relationships) do |x|
+    children = process_has_many(@relationships, persisted) do |x|
       update_foreign_key(persisted, x[:attributes], x)
     end
 
@@ -49,7 +50,11 @@ class JsonapiCompliable::Util::Persistence
 
   # The child's attributes should be modified to nil-out the
   # foreign_key when the parent is being destroyed or disassociated
+  #
+  # This is not the case for HABTM, whose "foreign key" is a join table
   def update_foreign_key(parent_object, attrs, x)
+    return if x[:sideload].type == :habtm
+
     if [:destroy, :disassociate].include?(x[:meta][:method])
       attrs[x[:foreign_key]] = nil
       update_foreign_type(attrs, x, null: true) if x[:is_polymorphic]
@@ -72,33 +77,45 @@ class JsonapiCompliable::Util::Persistence
 
   def associate_parents(object, parents)
     parents.each do |x|
-      x[:sideload].associate(x[:object], object) if x[:object] && object
+      if x[:object] && object
+        if x[:meta][:method] == :disassociate
+          x[:sideload].disassociate(x[:object], object)
+        else
+          x[:sideload].associate(x[:object], object)
+        end
+      end
     end
   end
 
   def associate_children(object, children)
     children.each do |x|
-      x[:sideload].associate(object, x[:object]) if x[:object] && object
+      if x[:object] && object
+        if x[:meta][:method] == :disassociate
+          x[:sideload].disassociate(object, x[:object])
+        else
+          x[:sideload].associate(object, x[:object])
+        end
+      end
     end
   end
 
   def persist_object(method, attributes)
     case method
       when :destroy
-        @resource.destroy(attributes[:id])
-      when :disassociate, nil
-        @resource.update(attributes)
+        call_resource_method(:destroy, attributes[:id], @caller_model)
+      when :update, nil, :disassociate
+        call_resource_method(:update, attributes, @caller_model)
       else
-        @resource.send(method, attributes)
+        call_resource_method(:create, attributes, @caller_model)
     end
   end
 
-  def process_has_many(relationships)
+  def process_has_many(relationships, caller_model)
     [].tap do |processed|
       iterate(except: [:polymorphic_belongs_to, :belongs_to]) do |x|
         yield x
         x[:object] = x[:sideload].resource
-          .persist_with_relationships(x[:meta], x[:attributes], x[:relationships])
+          .persist_with_relationships(x[:meta], x[:attributes], x[:relationships], caller_model)
         processed << x
       end
     end
@@ -128,4 +145,23 @@ class JsonapiCompliable::Util::Persistence
       yield x
     end
   end
+
+  # In the Resource, we want to allow:
+  #
+  # def create(attrs)
+  #
+  # and
+  #
+  # def create(attrs, parent = nil)
+  #
+  # 'parent' is an optional parameter that should not be part of the
+  # method signature in most use cases.
+  def call_resource_method(method_name, attributes, caller_model)
+    method = @resource.method(method_name)
+    if [2,-2].include?(method.arity)
+      method.call(attributes, caller_model)
+    else
+      method.call(attributes)
+    end
+  end
 end

data/lib/jsonapi_compliable/version.rb

@@ -1,3 +1,3 @@
 module JsonapiCompliable
-  VERSION = "0.7.9"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi_compliable
 version: !ruby/object:Gem::Version
-  version: 0.7.9
+  version: 0.8.0
 platform: ruby
 authors:
 - Lee Richmond