jsonapi_compliable 0.5.7 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51079670b0c1dedbb613140f18d466467aac8176
-  data.tar.gz: 25aa3bb0cafd200e8508d7e9492ca6334f2451d4
+  metadata.gz: 2f26c6ffeb63e0bd72ef36d3b2c86c6931a8f4fa
+  data.tar.gz: ae546cd488fe425c049efac300602efb8234ddce
 SHA512:
-  metadata.gz: a11eafba78c92d9b13d547b0ab43d6fec831a4f0f872c79d122a289f76be3a22dd16c53e78fb7f2a242c6b4bec92b3795fd3c0d8a8fee4b7d75788572200a938
-  data.tar.gz: a654eea7228308a1a057522fa6c0b5783a93c7644ef4c5b444100a1c543cfc3365e03a40d5f8aa9038b8557790dcfd60067ad8e0f6665e04a4636ec0f40dc1fa
+  metadata.gz: 595f742f0a782fddc1e161981d359fb9bce7976b014e556c8ce84f3f2c0365b0b035ff2ebb22a247b9776cb05b33e97bab180b613ed8167995004b3e258084a8
+  data.tar.gz: 5dea3994b495f6b1b455f23a10bf9169630b54ef0886082a0e99888cdf665f7dd621294dc6776a43c0e54c241f9fd983070ff432dd188f49a45d75cab745e1f4

data/gemfiles/rails_4.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
-  remote: ../
+  remote: ..
   specs:
-    jsonapi_compliable (0.5.5)
+    jsonapi_compliable (0.5.7)
       jsonapi-serializable (~> 0.1)
 
 GEM
@@ -205,4 +205,4 @@ DEPENDENCIES
   sqlite3
 
 BUNDLED WITH
-   1.13.6
+   1.14.6

data/gemfiles/rails_5.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
-  remote: ../
+  remote: ..
   specs:
-    jsonapi_compliable (0.5.5)
+    jsonapi_compliable (0.5.7)
       jsonapi-serializable (~> 0.1)
 
 GEM
@@ -209,4 +209,4 @@ DEPENDENCIES
   sqlite3
 
 BUNDLED WITH
-   1.13.6
+   1.14.6

data/lib/jsonapi_compliable.rb

@@ -4,6 +4,7 @@ require "jsonapi_compliable/resource"
 require "jsonapi_compliable/query"
 require "jsonapi_compliable/sideload"
 require "jsonapi_compliable/scope"
+require "jsonapi_compliable/deserializer"
 require "jsonapi_compliable/scoping/base"
 require "jsonapi_compliable/scoping/sort"
 require "jsonapi_compliable/scoping/paginate"
@@ -18,6 +19,9 @@ require "jsonapi_compliable/stats/payload"
 require "jsonapi_compliable/util/include_params"
 require "jsonapi_compliable/util/field_params"
 require "jsonapi_compliable/util/hash"
+require "jsonapi_compliable/util/relationship_payload"
+require "jsonapi_compliable/util/persistence"
+require "jsonapi_compliable/util/validation_response"
 
 # require correct jsonapi-rb before extensions
 if defined?(Rails)
@@ -30,8 +34,7 @@ require "jsonapi_compliable/extensions/extra_attribute"
 require "jsonapi_compliable/extensions/boolean_attribute"
 
 module JsonapiCompliable
-  autoload :Base,           'jsonapi_compliable/base'
-  autoload :Deserializable, 'jsonapi_compliable/deserializable'
+  autoload :Base, 'jsonapi_compliable/base'
 
   def self.included(klass)
     klass.instance_eval do

data/lib/jsonapi_compliable/adapters/abstract.rb

@@ -17,6 +17,10 @@ module JsonapiCompliable
         raise 'you must override #sideload in an adapter subclass'
       end
 
+      def transaction
+        raise 'you must override #transaction in an adapter subclass, it must yield'
+      end
+
       def resolve(scope)
         scope
       end

data/lib/jsonapi_compliable/adapters/active_record.rb

@@ -39,9 +39,42 @@ module JsonapiCompliable
         scope.to_a
       end
 
+      def transaction(model_class)
+        model_class.transaction do
+          yield
+        end
+      end
+
       def sideloading_module
         JsonapiCompliable::Adapters::ActiveRecordSideloading
       end
+
+      def associate(parent, child, association_name, association_type)
+        if association_type == :has_many
+          parent.association(association_name).loaded!
+          parent.association(association_name).add_to_target(child, :skip_callbacks)
+        else
+          child.send("#{association_name}=", parent)
+        end
+      end
+
+      def create(model_class, create_params)
+        instance = model_class.new(create_params)
+        instance.save
+        instance
+      end
+
+      def update(model_class, update_params)
+        instance = model_class.find(update_params.delete(:id))
+        instance.update_attributes(update_params)
+        instance
+      end
+
+      def destroy(model_class, id)
+        instance = model_class.find(id)
+        instance.destroy
+        instance
+      end
     end
   end
 end

data/lib/jsonapi_compliable/adapters/active_record_sideloading.rb

@@ -4,7 +4,7 @@ module JsonapiCompliable
       def has_many(association_name, scope: nil, resource:, foreign_key:, primary_key: :id, &blk)
         _scope = scope
 
-        allow_sideload association_name, resource: resource do
+        allow_sideload association_name, type: :has_many, resource: resource, foreign_key: foreign_key, primary_key: primary_key do
           scope do |parents|
             parent_ids = parents.map { |p| p.send(primary_key) }
             _scope.call.where(foreign_key => parent_ids.uniq.compact)
@@ -27,7 +27,7 @@ module JsonapiCompliable
       def belongs_to(association_name, scope: nil, resource:, foreign_key:, primary_key: :id, &blk)
         _scope = scope
 
-        allow_sideload association_name, resource: resource do
+        allow_sideload association_name, type: :belongs_to, resource: resource, foreign_key: foreign_key, primary_key: primary_key do
           scope do |parents|
             parent_ids = parents.map { |p| p.send(foreign_key) }
             _scope.call.where(primary_key => parent_ids.uniq.compact)

data/lib/jsonapi_compliable/adapters/null.rb

@@ -16,6 +16,10 @@ module JsonapiCompliable
       def sideload(scope, includes)
         scope
       end
+
+      def transaction
+        yield
+      end
     end
   end
 end

data/lib/jsonapi_compliable/base.rb

@@ -1,7 +1,6 @@
 module JsonapiCompliable
   module Base
     extend ActiveSupport::Concern
-    include Deserializable
 
     MAX_PAGE_SIZE = 1_000
 
@@ -32,7 +31,6 @@ module JsonapiCompliable
       @query_hash ||= query.to_hash[resource.type]
     end
 
-    # 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
@@ -45,6 +43,30 @@ module JsonapiCompliable
       resource.build_scope(scope, query, opts)
     end
 
+    def deserialized_params
+      @deserialized_params ||= JsonapiCompliable::Deserializer.new(params, request.env)
+    end
+
+    def jsonapi_create
+      created = resource.transaction do
+        resource.persist_with_relationships \
+          deserialized_params.meta,
+          deserialized_params.attributes,
+          deserialized_params.relationships
+      end
+      Util::ValidationResponse.new(created, deserialized_params)
+    end
+
+    def jsonapi_update
+      updated = resource.transaction do
+        resource.persist_with_relationships \
+          deserialized_params.meta,
+          deserialized_params.attributes,
+          deserialized_params.relationships
+      end
+      Util::ValidationResponse.new(updated, deserialized_params)
+    end
+
     def perform_render_jsonapi(opts)
       JSONAPI::Serializable::Renderer.render(opts.delete(:jsonapi), opts)
     end
@@ -54,7 +76,7 @@ module JsonapiCompliable
       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?
+      opts[:include] = deserialized_params.include_directive if force_includes?
       perform_render_jsonapi(opts)
     end
 
@@ -65,33 +87,8 @@ 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)
-      data = raw_params[:data] unless data
-
-      {}.tap do |forced|
-        (data[:relationships] || {}).each_pair do |relation_name, relation|
-          if relation[:data].is_a?(Array)
-            forced[relation_name] = {}
-            relation[:data].each do |datum|
-              forced[relation_name].deep_merge!(forced_includes(datum))
-            end
-          else
-            forced[relation_name] = forced_includes(relation[:data])
-          end
-        end
-      end
-    end
-
-    # Legacy
     def force_includes?
-      return false unless defined?(Rails)
-
-      %w(PUT PATCH POST).include?(request.method) and
-        raw_params.try(:[], :data).try(:[], :relationships).present?
+      not params[:data].nil?
     end
 
     module ClassMethods

data/lib/jsonapi_compliable/deserializer.rb

@@ -0,0 +1,139 @@
+class JsonapiCompliable::Deserializer
+  def initialize(payload, env)
+    @payload = payload
+    @env = env
+  end
+
+  def data
+    @payload[:data]
+  end
+
+  def id
+    data[:id]
+  end
+
+  def attributes
+    @attributes ||= raw_attributes.tap do |hash|
+      hash.merge!(id: id) if id
+    end
+  end
+
+  def attributes=(attrs)
+    @attributes = attrs
+  end
+
+  def method
+    case @env['REQUEST_METHOD']
+      when 'POST' then :create
+      when 'PUT', 'PATCH' then :update
+      when 'DELETE' then :destroy
+    end
+  end
+
+  def meta
+    {
+      type: data[:type],
+      temp_id: data[:'temp-id'],
+      method: method
+    }
+  end
+
+  def relationships
+    @relationships ||= process_relationships(raw_relationships)
+  end
+
+  def included
+    @payload[:included] || []
+  end
+
+  def include_directive(memo = {}, relationship_node = nil)
+    relationship_node ||= relationships
+
+    relationship_node.each_pair do |name, relationship_payload|
+      arrayified = [relationship_payload].flatten
+      next if arrayified.all? { |rp| removed?(rp) }
+
+      memo[name] ||= {}
+      deep_merge!(memo[name], sub_directives(memo[name], arrayified))
+    end
+
+    memo
+  end
+
+  private
+
+  def removed?(relationship_payload)
+    method = relationship_payload[:meta][:method]
+    [:disassociate, :destroy].include?(method)
+  end
+
+  def sub_directives(memo, relationship_payloads)
+    {}.tap do |subs|
+      relationship_payloads.each do |rp|
+        sub_directive = include_directive(memo, rp[:relationships])
+        deep_merge!(subs, sub_directive)
+      end
+    end
+  end
+
+  def deep_merge!(a, b)
+    JsonapiCompliable::Util::Hash.deep_merge!(a, b)
+  end
+
+  def process_relationships(relationship_hash)
+    {}.tap do |hash|
+      relationship_hash.each_pair do |name, relationship_payload|
+        name = name.to_sym
+
+        if relationship_payload[:data]
+          hash[name] = process_relationship(relationship_payload[:data])
+        end
+      end
+    end
+  end
+
+  def process_relationship(relationship_data)
+    if relationship_data.is_a?(Array)
+      relationship_data.map do |rd|
+        process_relationship_datum(rd)
+      end
+    else
+      process_relationship_datum(relationship_data)
+    end
+  end
+
+  def process_relationship_datum(datum)
+    temp_id = datum[:'temp-id']
+    included_object = included.find do |i|
+      next unless i[:type] == datum[:type]
+
+      (i[:id] && i[:id] == datum[:id]) ||
+        (i[:'temp-id'] && i[:'temp-id'] == temp_id)
+    end
+    included_object ||= {}
+    included_object[:relationships] ||= {}
+
+    attributes = included_object[:attributes] || {}
+    attributes[:id] = datum[:id] if datum[:id]
+    relationships = process_relationships(included_object[:relationships] || {})
+
+
+    {
+      meta: {
+        jsonapi_type: datum[:type],
+        temp_id: temp_id,
+        method: datum[:method].try(:to_sym)
+      },
+      attributes: attributes,
+      relationships: relationships
+    }
+  end
+
+  def raw_attributes
+    data[:attributes] || {}
+  end
+
+  def raw_relationships
+    data[:relationships] || {}
+  end
+end

data/lib/jsonapi_compliable/resource.rb

@@ -50,6 +50,10 @@ module JsonapiCompliable
       }
     end
 
+    def self.model(klass)
+      config[:model] = klass
+    end
+
     def self.sort(&blk)
       config[:sorting] = blk
     end
@@ -92,6 +96,7 @@ module JsonapiCompliable
           stats: {},
           sorting: nil,
           pagination: nil,
+          model: nil,
           adapter: Adapters::Abstract.new
         }
       end
@@ -115,6 +120,24 @@ module JsonapiCompliable
       Scope.new(base, self, query, opts)
     end
 
+    def create(create_params)
+      adapter.create(model, create_params)
+    end
+
+    def update(update_params)
+      adapter.update(model, update_params)
+    end
+
+    def destroy(id)
+      adapter.destroy(model, id)
+    end
+
+    def persist_with_relationships(meta, attributes, relationships)
+      persistence = JsonapiCompliable::Util::Persistence \
+        .new(self, meta, attributes, relationships)
+      persistence.run
+    end
+
     def association_names
       @association_names ||= begin
         if sideloading
@@ -190,6 +213,10 @@ module JsonapiCompliable
       self.class.config[:default_filters]
     end
 
+    def model
+      self.class.config[:model]
+    end
+
     def adapter
       self.class.config[:adapter]
     end
@@ -197,5 +224,11 @@ module JsonapiCompliable
     def resolve(scope)
       adapter.resolve(scope)
     end
+
+    def transaction
+      adapter.transaction(model) do
+        yield
+      end
+    end
   end
 end

data/lib/jsonapi_compliable/sideload.rb

@@ -6,18 +6,28 @@ module JsonapiCompliable
       :sideloads,
       :scope_proc,
       :assign_proc,
-      :grouper
+      :grouper,
+      :foreign_key,
+      :primary_key,
+      :type
 
-    def initialize(name, opts)
+    def initialize(name, type: nil, resource: nil, polymorphic: false, primary_key: :id, foreign_key: nil)
       @name               = name
-      @resource_class     = (opts[:resource] || Class.new(Resource))
+      @resource_class     = (resource || Class.new(Resource))
       @sideloads          = {}
-      @polymorphic        = !!opts[:polymorphic]
+      @polymorphic        = !!polymorphic
       @polymorphic_groups = {} if polymorphic?
+      @primary_key        = primary_key
+      @foreign_key        = foreign_key
+      @type               = type
 
       extend @resource_class.config[:adapter].sideloading_module
     end
 
+    def resource
+      @resource ||= resource_class.new
+    end
+
     def polymorphic?
       @polymorphic == true
     end
@@ -30,6 +40,10 @@ module JsonapiCompliable
       @assign_proc = blk
     end
 
+    def associate(parent, child)
+      resource_class.config[:adapter].associate(parent, child, name, type)
+    end
+
     def group_by(&grouper)
       @grouper = grouper
     end

data/lib/jsonapi_compliable/util/hash.rb

@@ -10,6 +10,11 @@ module JsonapiCompliable
         collection
       end
 
+      def self.deep_merge!(hash, other)
+        merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+        hash.merge!(other, &merger)
+      end
+
       def self.deep_dup(hash)
         if hash.respond_to?(:deep_dup)
           hash.deep_dup

data/lib/jsonapi_compliable/util/persistence.rb

@@ -0,0 +1,114 @@
+class JsonapiCompliable::Util::Persistence
+  def initialize(resource, meta, attributes, relationships)
+    @resource      = resource
+    @meta          = meta
+    @attributes    = attributes
+    @relationships = relationships
+  end
+
+  # belongs_to must be processed before/separately from has_many -
+  # we need to know the primary key value of the parent before
+  # persisting the child
+  #
+  # Flow:
+  # * process parents
+  # * update attributes to reflect parent primary keys
+  # * persist current object
+  # * associate temp id with current object
+  # * associate parent objects with current object
+  # * process children
+  # * associate children
+  # * return current object
+  def run
+    parents = process_belongs_to(@relationships)
+    update_foreign_key_for_parents(parents)
+
+    persisted = persist_object(@meta[:method], @attributes)
+    assign_temp_id(persisted, @meta[:temp_id])
+    associate_parents(persisted, parents)
+
+    children = process_has_many(@relationships) do |x|
+      update_foreign_key(persisted, x[:attributes], x)
+    end
+
+    associate_children(persisted, children)
+    persisted unless @meta[:method] == :destroy
+  end
+
+  # The child's attributes should be modified to nil-out the
+  # foreign_key when the parent is being destroyed or disassociated
+  def update_foreign_key(parent_object, attrs, x)
+    if [:destroy, :disassociate].include?(x[:meta][:method])
+      attrs[x[:foreign_key]] = nil
+    else
+      attrs[x[:foreign_key]] = parent_object.send(x[:primary_key])
+    end
+  end
+
+  def update_foreign_key_for_parents(parents)
+    parents.each do |x|
+      update_foreign_key(x[:object], @attributes, x)
+    end
+  end
+
+  def associate_parents(object, parents)
+    parents.each do |x|
+      x[:sideload].associate(x[:object], object) if x[:object] && object
+    end
+  end
+
+  def associate_children(object, children)
+    children.each do |x|
+      x[:sideload].associate(object, x[:object]) if x[:object] && object
+    end
+  end
+
+  def persist_object(method, attributes)
+    case method
+      when :destroy
+        @resource.destroy(attributes[:id])
+      when :disassociate, nil
+        @resource.update(attributes)
+      else
+        @resource.send(method, attributes)
+    end
+  end
+
+  def process_has_many(relationships)
+    [].tap do |processed|
+      iterate(except: [:belongs_to]) do |x|
+        yield x
+        x[:object] = x[:sideload].resource
+          .persist_with_relationships(x[:meta], x[:attributes], x[:relationships])
+        processed << x
+      end
+    end
+  end
+
+  def process_belongs_to(relationships)
+    [].tap do |processed|
+      iterate(only: [:belongs_to]) do |x|
+        x[:object] = x[:sideload].resource
+          .persist_with_relationships(x[:meta], x[:attributes], x[:relationships])
+        processed << x
+      end
+    end
+  end
+
+  def assign_temp_id(object, temp_id)
+    object.instance_variable_set(:@_jsonapi_temp_id, temp_id)
+  end
+
+  private
+
+  def iterate(only: [], except: [])
+    opts = {
+      resource: @resource,
+      relationships: @relationships,
+    }.merge(only: only, except: except)
+
+    JsonapiCompliable::Util::RelationshipPayload.iterate(opts) do |x|
+      yield x
+    end
+  end
+end

data/lib/jsonapi_compliable/util/relationship_payload.rb

@@ -0,0 +1,55 @@
+module JsonapiCompliable
+  module Util
+    class RelationshipPayload
+      attr_reader :resource, :payload
+
+      def self.iterate(resource:, relationships: {}, only: [], except: [])
+        instance = new(resource, relationships, only: only, except: except)
+        instance.iterate do |sideload, relationship_data, sub_relationships|
+          yield sideload, relationship_data, sub_relationships
+        end
+      end
+
+      def initialize(resource, payload, only: [], except: [])
+        @resource = resource
+        @payload  = payload
+        @only     = only
+        @except   = except
+      end
+
+      def iterate
+        payload.each_pair do |relationship_name, relationship_payload|
+          if sl = resource.sideload(relationship_name.to_sym)
+            if should_yield?(sl.type)
+              if relationship_payload.is_a?(Array)
+                relationship_payload.each do |rp|
+                  yield payload_for(sl, rp)
+                end
+              else
+                yield payload_for(sl, relationship_payload)
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def should_yield?(type)
+        (@only.length > 0 && @only.include?(type)) ||
+          (@except.length > 0 && !@except.include?(type))
+      end
+
+      def payload_for(sideload, relationship_payload)
+        {
+          sideload: sideload,
+          primary_key: sideload.primary_key,
+          foreign_key: sideload.foreign_key,
+          attributes: relationship_payload[:attributes],
+          meta: relationship_payload[:meta],
+          relationships: relationship_payload[:relationships]
+        }
+      end
+    end
+  end
+end

data/lib/jsonapi_compliable/util/validation_response.rb

@@ -0,0 +1,20 @@
+class JsonapiCompliable::Util::ValidationResponse
+  attr_reader :object
+
+  def initialize(object, deserialized_params)
+    @object = object
+    @deserialized_params = deserialized_params
+  end
+
+  def success?
+    if object.respond_to?(:errors)
+      object.errors.blank?
+    else
+      true
+    end
+  end
+
+  def to_a
+    [object, success?]
+  end
+end

data/lib/jsonapi_compliable/version.rb

@@ -1,3 +1,3 @@
 module JsonapiCompliable
-  VERSION = "0.5.7"
+  VERSION = "0.6.0"
 end

data/lib/jsonapi_compliable/write.rb

@@ -0,0 +1,93 @@
+class JsonapiCompliable::Write
+  attr_reader :resource
+
+  def initialize(opts = {})
+    @resource = opts[:resource]
+  end
+
+  def persist
+
+  end
+end
+
+resource.persist(obj, persistence_query, opts)
+
+p = Persistence.new(obj, resource: resource, params: params, opts: opts)
+p.persist
+
+
+allow_nested_write :books, resource: BookResource do
+  # rdefault to using BookResource in these
+  # hooks, but user can override to save
+  # via author
+  #
+  # assign temp id AFTER
+  # must handle NESTING genre
+  create do |author, book_params|
+    book_params[:author_id] = author.id
+    BookResource.create(book_params)
+    #book = Book.new(book_params)
+    #book.author_id = author.id
+    # instance variable set new id?
+    # # should be outside this method
+    #book.save!
+    #book
+  end
+
+  # HOW TO REUSE THIS ON /books
+  # should it be? i guess update, but not create
+  update do |author, book_params|
+    BookResource.update(book_params)
+    #book = Book.find(book_params[:id])
+    #book.update_attributes(book_params)
+    #book
+  end
+
+  # Might be fair to say you can remove rel
+  # but not destroy it
+  # if needed, add destroy hook later
+  delete do |author, book_params|
+    book_params[:author_id] = nil
+    BookResource.update(book_params)
+  end
+
+  destroy do |author, book_params|
+    BookResource.destroy(book_params)
+  end
+end
+
+    #def jsonapi_scope(scope, opts = {})
+      #resource.build_scope(scope, query, opts)
+    #end
+
+# controller
+#
+# book = Book.new(params)
+#
+# if jsonapi_persist(book)
+#   render_jsonapi(book)
+# else
+#   render_errors_for(book)
+# end
+
+
+
+class Writer
+      def initialize(parent)
+      end
+
+      def doit
+        relationships.each do |name, data|
+          if has_many?
+            created = Child.new(data, fk: fk)
+            created.TEMP_ID = data['temp_id']
+            created = created.save
+            mapping {data['temp_id'] => created.id}
+            parent.name 4<< created
+            parent.
+          else
+
+          end
+        end
+      end
+    end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi_compliable
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.6.0
 platform: ruby
 authors:
 - Lee Richmond
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-13 00:00:00.000000000 Z
+date: 2017-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable
@@ -149,7 +149,7 @@ files:
 - lib/jsonapi_compliable/adapters/active_record_sideloading.rb
 - lib/jsonapi_compliable/adapters/null.rb
 - lib/jsonapi_compliable/base.rb
-- lib/jsonapi_compliable/deserializable.rb
+- lib/jsonapi_compliable/deserializer.rb
 - lib/jsonapi_compliable/errors.rb
 - lib/jsonapi_compliable/extensions/boolean_attribute.rb
 - lib/jsonapi_compliable/extensions/extra_attribute.rb
@@ -170,8 +170,12 @@ files:
 - lib/jsonapi_compliable/util/field_params.rb
 - lib/jsonapi_compliable/util/hash.rb
 - lib/jsonapi_compliable/util/include_params.rb
+- lib/jsonapi_compliable/util/persistence.rb
+- lib/jsonapi_compliable/util/relationship_payload.rb
 - lib/jsonapi_compliable/util/render_options.rb
+- lib/jsonapi_compliable/util/validation_response.rb
 - lib/jsonapi_compliable/version.rb
+- lib/jsonapi_compliable/write.rb
 homepage: 
 licenses:
 - MIT

data/lib/jsonapi_compliable/deserializable.rb

@@ -1,127 +0,0 @@
-# This will convert JSONAPI-compatible POST/PUT payloads
-# into something Rails better understands. Example:
-#
-# {
-#   "data": {
-#     "type": "articles",
-#     "attributes": { "title": "the first article" },
-#     "relationships": {
-#       "tags": {
-#         "data": [{
-#           "type": "tags",
-#           "attributes": { "name": "One" }
-#         }, {
-#           "type": "tags",
-#           "attributes": { "name": "Two" }
-#         }]
-#       }
-#     }
-#   }
-# }
-#
-# Into:
-#
-# {
-#    article: {
-#      title: 'the first article',
-#      tags_attributes: [
-#        { name: 'One' },
-#        { name: 'Two' },
-#      ]
-#    }
-# }
-#
-# Why we don't use AMS deserialization - AMS will:
-# * not support relationship data
-# * override foreign key incorrectly, ie
-#   post_id incorrectly becomes nil if post relation is nil,
-#   even if it is in the attributes payload
-#
-# Usage:
-#
-# In controller:
-#
-# before_action :deserialize_jsonapi!, only: [:my_action]
-
-module JsonapiCompliable
-  module Deserializable
-    extend ActiveSupport::Concern
-
-    included do
-      attr_accessor :raw_params
-    end
-
-    class Deserialization
-      def initialize(params, namespace: true)
-        @params = params
-        @namespace = namespace
-      end
-
-      def deserialize
-        hash = attributes
-        hash = hash.merge(relationships)
-        hash = @namespace ? { parsed_type => hash } : hash
-        hash.reverse_merge(@params.except(:data)).deep_symbolize_keys
-      end
-
-      private
-
-      def parsed_type
-        @params[:data][:type].underscore.singularize.to_sym
-      end
-
-      def attributes
-        attrs = {}
-        attrs[:id] = @params[:data].try(:[], :id) if @params[:data].try(:[], :id)
-        attrs.merge!(@params[:data].try(:[], :attributes) || {})
-        attrs
-      end
-
-      def relationships
-        return {} if @params[:data].try(:[], :relationships).blank?
-
-        {}.tap do |hash|
-          @params[:data][:relationships].each_pair do |relationship_name, payload|
-            parsed_relation = parse_relation(payload)
-
-            if parsed_relation.present?
-              hash["#{relationship_name}_attributes".to_sym] = parsed_relation
-            end
-          end
-        end
-      end
-
-      def parse_relation(payload)
-        if payload[:data].is_a?(Array)
-          parse_has_many(payload[:data])
-        else
-          parse_belongs_to(payload)
-        end
-      end
-
-      def parse_belongs_to(payload)
-        self.class.new(payload, namespace: false).deserialize
-      end
-
-      def parse_has_many(payloads)
-        payloads.map do |payload|
-          payload = { data: payload }
-          self.class.new(payload, namespace: false).deserialize
-        end.compact
-      end
-    end
-
-    def deserialize_jsonapi!
-      self.raw_params = Util::Hash.deep_dup(self.params)
-
-      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