daylight 0.9.0.rc2 → 0.9.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6bf59fd5ce024afa3fc59ddb2d66363f8f5d5209
-  data.tar.gz: 7dfddabc42f86705bf30f51cdbe41cd879e58bb6
+  metadata.gz: bb3cda8546b99d74c72bf1af1ca14aabb51f3d8d
+  data.tar.gz: 41ad2d678d9aa293cc766179e2441789b7b351be
 SHA512:
-  metadata.gz: 97b17af7fc52458bf4f0b255aaf404fa55821ca6b28b2be6885ecadd3618a22ccbc613b8c64ef011aebc4b12e905164ce29619598fd6b63ed19a0c169d28d5c9
-  data.tar.gz: 757ffe41b8d52bc4fd6e373a3a2041541c1549e8f7878d88fa9c45d5d5ccdca7b546a58164588e59c30c52a62433adf5321bb4b889efe543bcc20dd1f4aed39a
+  metadata.gz: 75780f4b059adb79463f13b0b41e01ae105ecdcad262ca59f133d4624c0fe5557bcc927f9f8a341961d6be8bba5a1720fbd70af0e749202ee8d2aca704b95a99
+  data.tar.gz: 438f45ccd0e69581e5c2217d989bfe0b9fa238c8665d184632a76cd9055c6a83cb3df5257c7376c4a968b1904b5e61685f2dc2eb38ac7f97776437222f16edbd

data/doc/usage.md

@@ -365,8 +365,9 @@ server-side.
 Daylight adds additional functionality directly on the association:
 * add new resources
 * update existing resources
-* add a new resource to a collection
+* add a resource to a collection
 * associate two existing resources
+* delete from an association
 
 Currently, `ActiveResource` will only let you associate a resource by setting
 the `foreign_key` directly on a model.
@@ -485,48 +486,27 @@ You can also add a nested object to an existing collection:
 
 #### Updating a Nested Resource
 
-Updates to nested resources are not saved by saving the parent resource.
-You must save the nested resources directly:
+Updates to nested resources are saved by saving the parent resource.
 
   ````ruby
     post = API::Post.first
     post.author.full_name = "Reid MacDonald"
-    post.author.save #=> true
-
-    post = API::Post.first
-    post.author.full_name #=> "Reid MacDonald"
-  ````
-
-This is the same as saying:
-
-  ````ruby
-    post = API::Post.first
-
-    author = post.author
-    author.full_name = "Reid MacDonald"
-    author.save #=> true
+    post.save #=> true
 
     post = API::Post.first
     post.author.full_name #=> "Reid MacDonald"
   ````
-
 The same is true of nested objects in collections:
 
   ````ruby
     post = API::Post.first
-
-    first_comment = post.comments.first
-    first_comment.message = "First!"
-    first_comment.save #=> true
+    post.comments.first.message = "First!"
+    post.save #=> true
 
     post = API::Post.first
     post.comments.first.message #=> "First!"
   ````
 
-> FUTURE [#5](https://github.com/att-cloud/daylight/issues/5):
-> Updates to the associated nested resource do not get saved when the parent
-> resources are saved and they should be.
-
 #### Associating an Existing Nested Resources
 
 Associating using an existing nested records is possible with Daylight.  The
@@ -557,8 +537,31 @@ This also will work to add to a collection on a new or existing resource:
     post.commenters.find {|c| c.username == 'reidmix'} # #<API::V1::User:0x007fe2cfc45ce8 ..>
   ````
 
-> FUTURE [#15](https://github.com/att-cloud/daylight/issues/15):
-> There is no way to remove an nested resource from a collection nor empty the collection.
+#### Deleting Nested Resources
+
+A nested resource can be removed from a collection:
+
+  ````ruby
+    post = API::Post.first
+    post.comments.count #=> 4
+    post.comments.shift
+    post.save #=> true
+
+    post = API::Post.first
+    post.comments.count #=> 3
+  ````
+
+A collection can also be reset:
+
+  ````ruby
+    post = API::Post.first
+    post.comments.count #=> 4
+    post.comments = []
+    post.save #=> true
+
+    post = API::Post.first
+    post.comments.count #=> 0
+  ````
 
 ### More Chaining
 
@@ -788,17 +791,18 @@ When saving this model from the client errors will be exposed similar to
 
 With the introduction of and use of
 [Strong Parameters](http://guides.rubyonrails.org/action_controller_overview.html#strong-parameters)
-unpermitted or missing attributes will be detected.
+unpermitted or missing attributes can be detected if `action_on_unpermitted_parameters` is set to `:raise`
+in configuration:
 
-> FUTURE [#8](https://github.com/att-cloud/daylight/issues/8):
-> Would be nice to know which parameter is raising the error and if it was a
-> _required_ parameter or an _unpermitted_ one.
+  ````ruby
+  config.action_controller.action_on_unpermitted_parameters = :raise
+  ````
 
 Lets say `created_at` is not permitted on the `PostController`:
   ````ruby
   post = API::Post.new(created_at: Time.now)
   post.save             # => false
-  post.errors.messages  # => {:base=>["Unpermitted or missing attribute"]}
+  post.errors.messages  # => {'created_at'=>['unpermitted parameter']}
   ````
 
 ### Bad Requests

data/lib/daylight.rb

@@ -19,6 +19,7 @@ module Daylight
     autoload :ReadOnly
     autoload :ResourceProxy
     autoload :ReflectionExt
+    autoload :AssociationPersistance
     autoload :API
   end
 end

data/lib/daylight/api.rb

@@ -44,6 +44,7 @@ class Daylight::API < ActiveResource::Base
   include Daylight::ReadOnly
   include Daylight::Refinements
   include Daylight::Associations
+  prepend Daylight::AssociationPersistance
 
   class << self
     attr_reader    :version, :versions, :namespace
@@ -186,7 +187,7 @@ class Daylight::API < ActiveResource::Base
       end
   end
 
-  attr_reader :metadata
+  attr_reader :metadata, :hashcode, :association_hashcodes
 
   ##
   # Extends ActiveResource to allow for saving metadata from the responses on
@@ -199,6 +200,9 @@ class Daylight::API < ActiveResource::Base
     extract_metadata!(attributes)
 
     super
+
+    @association_hashcodes = {}.with_indifferent_access
+    @hashcode = self.attributes.hash
   end
 
   ##
@@ -269,6 +273,30 @@ class Daylight::API < ActiveResource::Base
       end
     end
 
+    ##
+    # Load object(s) for a reflection name from the given values which could be
+    # an Array or a Hash
+
+    def load_attributes_for(name, value)
+      case value
+        when Array
+          resource = nil
+          value.map do |attrs|
+            if attrs.is_a?(Hash)
+              resource ||= find_or_create_resource_for_collection(name)
+              resource.new(attrs, true)
+            else
+              attrs.duplicable? ? attrs.dup : attrs
+            end
+          end
+        when Hash
+          resource = find_or_create_resource_for(name)
+          resource.new(value, true)
+        else
+          value.duplicable? ? value.dup : value
+      end
+    end
+
   private
 
     ##

data/lib/daylight/association_persistance.rb

@@ -0,0 +1,57 @@
+module Daylight::AssociationPersistance
+
+  # has our attributes changed since we were loaded?
+  def changed?
+    new? || hashcode != attributes.hash
+  end
+
+  def serializable_hash(options=nil)
+    super((options || {}).reverse_merge(include: association_includes))
+  end
+
+  protected
+
+    ##
+    # returns nil if no changes (ourself or our children)
+    # returns empty hash if we've changed, but our children haven't
+    # returns include key if some of our children have changed
+    #
+    # { include: { post: { include: { comment: {} } } }
+
+    def association_includes
+      include_hash = {}
+
+      self.class.reflection_names.each do |reflection_name|
+        association = instance_variable_get("@#{reflection_name}")
+        reflection_attribute_name = "#{reflection_name}_attributes"
+        # ignore associations that have not been set
+        next unless association
+
+        # recurse into the child(ren)
+        child_include_hash =
+          if association.respond_to?(:to_ary)
+            # merge all the includes from all the children
+            children_includes = association.to_ary.map {|child| child.association_includes }.compact
+            children_includes.reduce(:merge) if children_includes.present?
+          else
+            association.association_includes
+          end
+
+        if child_include_hash.present?
+          include_hash[reflection_attribute_name] = {include: child_include_hash}
+        elsif child_include_hash || changed_associations.include?(reflection_name)
+          include_hash[reflection_attribute_name] = {}
+        end
+      end
+
+      include_hash if changed? || include_hash.present?
+    end
+
+    ##
+    # list of associations that have been modified
+    #
+    def changed_associations
+      association_hashcodes.select {|association, code| send(association).hash != code }
+    end
+
+end

data/lib/daylight/associations.rb

@@ -73,7 +73,6 @@ module Daylight::Associations
         # define setter that places the value directly in the attributes using
         # the nested_attributes functionality server-side
         define_method "#{reflection.name}=" do |value|
-          self.attributes[nested_attribute_key] = value
           instance_variable_set(:"@#{reflection.name}", value)
         end
 
@@ -93,15 +92,20 @@ module Daylight::Associations
     # ActiveResource::Associations#belongs_to
 
     def belongs_to name, options={}
-      # continue to let the original do all the work.
-      super.tap do |reflection|
+      create_reflection(:belongs_to, name, options).tap do |reflection|
+
+        nested_attribute_key = "#{reflection.name}_attributes"
+
+        # setup the resource_proxy to fetch the results
+        define_cached_method reflection.name, cache_key: nested_attribute_key do
+          reflection.klass.find(send(reflection.foreign_key))
+        end
 
         # Defines a setter caching the value in an instance variable for later
         # retrieval.  Stash value directly in the attributes using the
         # nested_attributes functionality server-side.
         define_method "#{reflection.name}=" do |value|
           attributes[reflection.foreign_key] = value.id           # set the foreign key
-          attributes["#{reflection.name}_attributes"] = value     # set the nested_attributes
           instance_variable_set(:"@#{reflection.name}", value)    # set the cached value
         end
       end
@@ -198,7 +202,6 @@ module Daylight::Associations
         end
 
         define_method "#{reflection.name}=" do |value|
-          attributes["#{reflection.name}_attributes"] = value     # set the nested_attributes
           value.attributes[:"#{self.class.element_name}_id"] = self.id
           instance_variable_set(:"@#{reflection.name}", value)    # set the cached value
         end
@@ -233,14 +236,23 @@ module Daylight::Associations
           cache_key  = options[:cache_key] || method_name
           attributes = options.has_key?(:index) ? @attributes[options[:index]] : @attributes
 
-          if instance_variable_defined?(ivar_name)
-            instance_variable_get(ivar_name)
-          elsif attributes.include?(cache_key)
-            attributes[cache_key]
-          else
-            instance_variable_set ivar_name, send(uncached_method_name)
-          end
+          return instance_variable_get(ivar_name) if instance_variable_defined?(ivar_name)
+
+          value =
+            if attributes.include?(cache_key)
+              load_attributes_for(method_name, attributes[cache_key])
+            else
+              send(uncached_method_name)
+            end
+
+          # Track of the association hashcode for changes
+          association_hashcodes[method_name] = value.hash
+
+          instance_variable_set ivar_name, value
         end
+
+        # alias our wrapper so calls to the attributes work
+        alias_method "#{method_name}_attributes", method_name
       end
 
   end

data/lib/daylight/read_only.rb

@@ -23,14 +23,14 @@ module Daylight::ReadOnly
   end
 
   ##
-  # Adds API specific options when generating json.
+  # Adds API specific options when generating a serializable hash.
   # Removes read_only attributes for requests.
   #
   # See
   # except_read_only
 
-  def as_json(options={})
-    super(except_read_only(options))
+  def serializable_hash(options=nil)
+    super(except_read_only(options || {}))
   end
 
   ##
@@ -44,6 +44,7 @@ module Daylight::ReadOnly
     super(except_read_only(options))
   end
 
+
   ##
   # Writers for read_only attributes are not included as methods
   #--
@@ -75,7 +76,7 @@ module Daylight::ReadOnly
     ##
     # Ensures that read_only attributes are merged in with `:except` options.
 
-    def except_read_only options
+    def except_read_only options={}
       options.merge(except: (options[:except]||[]).push(*read_only))
     end
 

data/lib/daylight/resource_proxy.rb

@@ -18,17 +18,6 @@ class Daylight::ResourceProxy
     @association_name, @association_resource = association.first
   end
 
-  ##
-  # Delegates appending to the association resource when available
-
-  def << value
-    if association_resource
-      association_resource.send("#{association_name}=", records.elements << value)
-    else
-      raise NoMethodError, "undefined method `<<' for #{self}"
-    end
-  end
-
   ##
   # Sets `from` URL on a request
   def from from
@@ -118,11 +107,16 @@ class Daylight::ResourceProxy
   end
 
   ##
-  # Sets the limit to the current parameters, and fetches the first result.
+  # If loaded, return the first element, otherwise -
+  # sets the limit to the current parameters, and fetches the first result.
   # Immediately issues the request to the API.
 
   def first
-    limit(1).to_a.first
+    if loaded?
+      to_a.first
+    else
+      limit(1).to_a.first
+    end
   end
 
   ##
@@ -183,8 +177,7 @@ class Daylight::ResourceProxy
 
   ##
   # Will attempt to fulfill the method if it exists on the resource or if it
-  # exists on an Array.  Defines or delegates the method on for subsequent
-  # execution.
+  # exists on an Array.  Delegates the method on for subsequent execution.
 
   def method_missing(method_name, *args, &block)
     if resource_class.respond_to?(method_name)
@@ -193,8 +186,9 @@ class Daylight::ResourceProxy
       end
       resource_class.send(method_name, *args, &block)
     elsif Array.method_defined?(method_name)
-      self.class.delegate method_name, :to => :to_a
-      to_a.send(method_name, *args, &block)
+      wrap_array_method(method_name)
+      # resend call to newly wrapped method
+      send(method_name, *args, &block)
     else
       super
     end
@@ -223,4 +217,29 @@ class Daylight::ResourceProxy
       @records = nil
       self
     end
+
+  private
+
+    ##
+    # Create a wrapper method around a called array method that updates the assocation
+    # resource if the array has changed.
+    # This way we can propagate those changes to the server when the client model is saved.
+
+    def wrap_array_method(method_name)
+      self.class.send(:define_method, method_name) do |*args, &block|
+        array = records.elements
+        count_before = array.count
+        response = array.send(method_name, *args, &block)
+        # update the association if the array has changed
+        association_resource.send("#{association_name}=", array) if association_name && count_before != array.count
+        response
+      end
+    end
+
+    ##
+    # has this proxy loaded its data yet?
+
+    def loaded?
+      @records.present?
+    end
 end

data/lib/daylight/version.rb

@@ -3,7 +3,7 @@ module Daylight
     MAJOR = 0
     MINOR = 9
     PATCH = 0
-    BUILD = 'rc2'
+    BUILD = 'rc3'
 
     Daylight::VERSION = STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
   end

data/rails/daylight/api_controller.rb

@@ -49,6 +49,8 @@ class Daylight::APIController < ApplicationController
   include Daylight::Helpers
   include VersionedUrlFor
 
+  ALLOWED_WHERE_PARAMS = [:id, :order, :limit, :offset, :associated, :remoted, :format].freeze
+
   API_ACTIONS = [:index, :create, :show, :update, :destroy, :associated, :remoted].freeze
   class_attribute :record_name, :collection_name, :model_name, instance_predicate: false
 
@@ -199,6 +201,16 @@ class Daylight::APIController < ApplicationController
       respond_to?(model_params_name, true) ? send(model_params_name) : params[model_key]
     end
 
+    ##
+    # Permits known parameters for quering
+    # This has become necessary as of Rails 4.0.9 and 4.1.5 because of this security fix:
+    # https://groups.google.com/forum/#!topic/rubyonrails-security/M4chq5Sb540
+    def where_params
+      params.permit(*ALLOWED_WHERE_PARAMS,
+                    filters: params[:filters].try(:keys),
+                    scopes:  [])
+    end
+
     ##
     # Instance-level delegate of the `primary_key` method
     #
@@ -227,7 +239,7 @@ class Daylight::APIController < ApplicationController
     # See:
     # Daylight::Refiners.refine_by
     def index
-      render json: self.collection = model.refine_by(params)
+      render json: self.collection = model.refine_by(where_params)
     end
 
     ##
@@ -330,7 +342,7 @@ class Daylight::APIController < ApplicationController
     # Daylight::Helpers.associated_params
     # RouteOptions
     def associated
-      render json: self.collection = model.associated(params), root: associated_params
+      render json: self.collection = model.associated(where_params), root: associated_params
     end
 
     ##
@@ -350,6 +362,6 @@ class Daylight::APIController < ApplicationController
     # Daylight::Helpers.remoted_params
     # RouteOptions
     def remoted
-      render json: self.collection = model.remoted(params), root: remoted_params
+      render json: self.collection = model.remoted(where_params), root: remoted_params
     end
 end

data/rails/extensions/nested_attributes_ext.rb

@@ -19,7 +19,10 @@ module NestedAttributesExt
     def assign_nested_attributes_for_collection_association association_name, attributes_collection
       return if attributes_collection.nil?
 
+      return if is_collection_multilevel?(association_name)
+
       associate_existing_records(association_name, attributes_collection)
+      unassociate_missing_records(association_name, attributes_collection)
 
       super
     end
@@ -63,30 +66,73 @@ module NestedAttributesExt
       return if attribute_ids.empty?
 
       association = association(association_name)
-      primary_key = association.klass.primary_key.to_sym
-
-      # get known existing ids on the association
-      existing_record_ids = if association.loaded?
-          association.target.map(&primary_key)
-        else
-          association.scope.where(primary_key => attribute_ids).pluck(primary_key)
-        end
+      foreign_key = association.reflection.foreign_key
 
-      # unassociated records are those that are not part of existing in the association
-      unassociated_record_ids = attribute_ids.map(&:to_s) - existing_record_ids.map(&:to_s)
+      # unassociated records ids are those not existing in the association ids
+      unassociated_record_ids = attribute_ids.map(&:to_s) - association.ids_reader.map(&:to_s)
 
       # we are about to set all foreign_keys, remove any foreign_key references in
       # unassigned records attributes so they don't get clobbered
       attributes_collection.map do |a|
         if unassociated_record_ids.include?((a['id'] || a[:id]).to_s)
-          key = association.reflection.foreign_key
-          a.delete(key) || a.delete(key.to_sym)
+          a.delete(foreign_key) || a.delete(foreign_key.to_sym)
         end
       end
 
       # concat the unassociated records to the association
       association.concat(association.klass.find(unassociated_record_ids))
     end
+
+    ##
+    # Determines removed records from existing records on the association and sets their
+    # foreign keys to NULL
+    def unassociate_missing_records(association_name, attributes_collection)
+      # determine existing records, bail if there are none specified by 'id'
+      attribute_ids = attributes_collection.map {|a| (a['id'] || a[:id]) }.compact
+
+      association = association(association_name)
+
+      # removed records are those that are not part of existing in the association
+      removed_record_ids = association.ids_reader.map(&:to_s) - attribute_ids.map(&:to_s)
+
+      # remove the records from the association
+      association.delete(*removed_record_ids) unless removed_record_ids.empty?
+    end
+
+    ##
+    # returns true if the collection is a has_many :through or has_and_belongs_to_many
+    # association.
+    #
+
+    def is_collection_multilevel?(association_name)
+      association = association(association_name)
+
+      type = has_many_type(association)
+      return false unless type
+
+      logger.error <<-ERROR
+Attempt to modify "#{association_name}" collection on #{self.class.name}.
+  Ignoring modification for #{type} used with
+  accepts_nested_attributes_for because it causes unexpected results.
+ERROR
+    end
+
+    ##
+    # Return a description of the association if it is a has_and_belongs_to_many
+    # or a has_many :through.
+    #
+    # Takes differences between Rails 4.0 and 4.1 into account.
+
+    def has_many_type(association)
+      reflection = association.reflection
+      if reflection.try(:has_and_belongs_to_many?) ||
+         (reflection.try(:parent_reflection) &&
+          reflection.parent_reflection.last.try(:macro) == :has_and_belongs_to_many)
+        'has_and_belongs_to_many'
+      elsif reflection.options.has_key?(:through)
+        'has_many :through'
+      end
+    end
 end
 
 ActiveRecord::Base.class_eval do

data/spec/lib/daylight/api_spec.rb

@@ -119,13 +119,14 @@ describe Daylight::API do
 
     it "does not objectify a known reflection's attributes" do
       test = TestDescendant.find(1)
-      test.child_attributes['id'].should == 2
+      test.attributes['child_attributes']['id'].should == 2
     end
 
     it "objectifies hashes within a known reflection's attributes" do
       test = TestDescendant.find(1)
-      test.child_attributes['toy'].should be_kind_of(ActiveResource::Base)
-      test.child_attributes['toy'].attributes.should == {'id' => 5, 'name' => 'slinky'}
+      toy = test.attributes['child_attributes']['toy']
+      toy.should be_kind_of(ActiveResource::Base)
+      toy.attributes.should == {'id' => 5, 'name' => 'slinky'}
     end
 
     it "still objectifies other attributes" do
@@ -188,4 +189,38 @@ describe Daylight::API do
       test.metadata.should be_present
     end
   end
+
+  describe :load_attributes_for do
+    let(:test) { TestDescendant.new }
+
+    it 'creates a resource from a Hash based on the name' do
+      obj = test.send(:load_attributes_for, :test_descendant, {name: 'foo'})
+      obj.should be_instance_of(TestDescendant)
+      obj.name.should == 'foo'
+    end
+
+    it 'creates a resource for each Hash in an array' do
+      obj = test.send(:load_attributes_for, :test_descendants, [{name: 'foo'}, {name: 'bar'}])
+      obj.size.should == 2
+      obj.first.should be_instance_of(TestDescendant)
+      obj.first.name.should == 'foo'
+    end
+
+    it 'dups each object in a given array if it is not a Hash' do
+      data = %w[one two three]
+      obj = test.send(:load_attributes_for, :test_descendants, data)
+      obj.size.should == 3
+      obj.first.should be_instance_of(String)
+      obj.first.should == 'one'
+      obj.object_id.should_not == data.first.object_id
+    end
+
+    it 'otherwise creates a dup of the given value' do
+      my_string = 'my string'
+      obj = test.send(:load_attributes_for, :test_descendant, my_string)
+      obj.should be_instance_of(String)
+      obj.should == 'my string'
+      obj.object_id.should_not == my_string.object_id
+    end
+  end
 end

data/spec/lib/daylight/association_persistance_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe Daylight::AssociationPersistance do
+
+  class GrandchildPersistanceTestClass < Daylight::API
+  end
+
+  class RelatedPersistanceTestClass < Daylight::API
+    has_many :grandchildren, class_name: GrandchildPersistanceTestClass
+  end
+
+  class PersistanceTestClass < Daylight::API
+    has_many :children, class_name: 'RelatedPersistanceTestClass'
+    belongs_to :parent, class_name: 'RelatedPersistanceTestClass'
+
+    def parent_id ; 1 ; end
+  end
+
+  before do
+    data = {id: 1, name: 'test'}
+    stub_request(:get, %r{#{PersistanceTestClass.element_path(1)}}).to_return(body: data.to_json)
+    stub_request(:get, %r{#{RelatedPersistanceTestClass.element_path(1)}}).to_return(body: data.to_json)
+    stub_request(:get, %r{#{RelatedPersistanceTestClass.element_path(2)}}).to_return(body: data.merge(id:2).to_json)
+    stub_request(:get, %r{/persistance_test_classes/1/children\.json}).to_return(body: [data, data].to_json)
+    stub_request(:get, %r{/related_persistance_test_classes/1/grandchildren\.json}).to_return(body: [data, data].to_json)
+  end
+
+  let(:object) { PersistanceTestClass.find(1) }
+
+  describe :changed? do
+
+    it 'returns false if the object is not modified' do
+      object.changed?.should be_false
+    end
+
+    it 'returns true if the object has a field modified' do
+      object.name = 'this is a change'
+
+      object.changed?.should be_true
+    end
+
+    it 'returns true if the object has a modified association' do
+      object.parent = RelatedPersistanceTestClass.new
+
+      object.changed?.should be_true
+    end
+
+    it 'returns true if the object is new' do
+      PersistanceTestClass.new.changed?.should be_true
+    end
+  end
+
+  describe :include_child_updates do
+    it 'does not include associations if has not been loaded' do
+      hash = object.serializable_hash
+      hash['parent_attributes'].should be_nil
+      hash['children_attributes'].should be_nil
+    end
+
+    it 'includes the single belongs_to/has_one assocation if it has changed' do
+      object.parent.should_not be_nil
+      object.parent.name = 'updated name'
+      hash = object.serializable_hash
+      hash['parent_attributes'].should be_present
+    end
+
+    it 'includes all children in a has_many type relation if any of them have changed' do
+      object.children.should be_present
+      object.children[0].name = 'updated name'
+
+      hash = object.serializable_hash
+      hash['children_attributes'].count.should == 2
+    end
+
+    it 'does not include the association attribute if nothing has changed in the collection' do
+      object.children.should be_present
+
+      hash = object.serializable_hash
+      hash.should_not have_key('children_attributes')
+    end
+
+    it 'does not include the single child if it has not changed' do
+      object.parent.should be_present
+
+      hash = object.serializable_hash
+      hash.should_not have_key('parent_attributes')
+    end
+
+    it 'still includes associations when there is a new child object' do
+      object.children.should be_present
+      object.children << RelatedPersistanceTestClass.new
+      object.children.count.should == 3
+
+      hash = object.serializable_hash
+      hash['children_attributes'].count.should == 3
+    end
+
+    it 'still includes associations when an additional persisted child object is added' do
+      object.children.should be_present
+      object.children << RelatedPersistanceTestClass.find(1)
+      object.children.count.should == 3
+
+      hash = object.serializable_hash
+      hash['children_attributes'].count.should == 3
+    end
+
+    it 'still includes has_one associations when persisted child object is set' do
+      object.parent.should be_present
+      object.parent = RelatedPersistanceTestClass.find(2)
+
+      hash = object.serializable_hash
+      hash['parent_attributes'].should be_present
+    end
+
+    it 'does not include has_one associations when it is replaced with the same object' do
+      object.parent.should be_present
+      object.parent = RelatedPersistanceTestClass.find(1)
+
+      hash = object.serializable_hash
+      hash['parent_attributes'].should_not be_present
+    end
+
+    it 'handles grandchild modifications' do
+      object.children[0].grandchildren[0].name = 'updated name'
+      hash = object.serializable_hash
+      hash['children_attributes'][0]['grandchildren_attributes'][0]['name'].should == 'updated name'
+    end
+  end
+
+end

data/spec/lib/daylight/associations_spec.rb

@@ -53,12 +53,6 @@ describe Daylight::Associations do
         collection.should be_a Array
       end
 
-      it "sets the associations directly the attributes hash" do
-        new_resource.related_test_classes = ["associated instances"]
-
-        new_resource.attributes['related_test_classes_attributes'].should == ["associated instances"]
-      end
-
       it "fetches the stored associations out of the attributes when they are set" do
         new_resource.related_test_classes = ["associated instances"]
 
@@ -107,12 +101,6 @@ describe Daylight::Associations do
         proxy.to_params[:filters].should == {wibble: 'wobble'}
       end
 
-      it "sets the associations directly the attributes hash" do
-        existing_resource.related_test_classes = ["associated instances"]
-
-        existing_resource.attributes['related_test_classes_attributes'].should == ["associated instances"]
-      end
-
       it "fetches the stored associations out of the attributes when they exist" do
         existing_resource.related_test_classes = ["associated instances"]
 
@@ -150,13 +138,6 @@ describe Daylight::Associations do
 
       resource.attributes['parent_id'].should == 789
     end
-
-    it 'sets the parent directly in the nested attributes hash' do
-      resource = AssociationsTestClass.find(1)
-      resource.parent = RelatedTestClass.new(id: 789, name: 'new parent')
-
-      resource.attributes['parent_attributes'].should == resource.parent
-    end
   end
 
   describe :belongs_to_through do
@@ -167,6 +148,7 @@ describe Daylight::Associations do
           parent_id: 456, # ignored because of parent_id method
           parent_attributes: {
             id: 456,
+            name: 'nested',
             grandparent_id: 3
           }
         }
@@ -190,12 +172,12 @@ describe Daylight::Associations do
       stub_request(:get, %r{#{RelatedTestClass.element_path(3)}}).to_return(body: related_data.merge(id: 3).to_json)
     end
 
-    it 'still fetches the parent object' do
+    it 'loads the parent object from the original response' do
       resource = AssociationsTestClass.find(1)
 
       resource.parent.should_not be_nil
       resource.parent.id.should   == 456
-      resource.parent.name.should == 'related'
+      resource.parent.name.should == 'nested'
     end
 
     it 'fetches the "through" object' do
@@ -260,13 +242,6 @@ describe Daylight::Associations do
 
       resource.associate.associations_test_class_id.should == resource.id
     end
-
-    it 'sets the associate directly in the nested attributes hash' do
-      resource = AssociationsTestClass.find(1)
-      resource.associate = RelatedTestClass.new(id: 333, name: 'Rik Mayall')
-
-      resource.attributes['associate_attributes'].should == resource.associate
-    end
   end
 
   describe :remote do

data/spec/lib/daylight/resource_proxy_spec.rb

@@ -50,16 +50,10 @@ describe Daylight::ResourceProxy do
     it "still thrown when chaining" do
       expect { ProxyTestClass.foo.not_a_method }.to raise_error(NoMethodError)
     end
-
-    it "still thrown when appending to scopes" do
-      ProxyTestClass.foo.association_resource.should be_nil
-
-      expect { ProxyTestClass.foo << ['foo class'] }.to raise_error(NoMethodError)
-    end
   end
 
   describe "Array methods" do
-    it "supported as a generated method" do
+    it "supports through generated methods" do
       mock    = ProxyTestClass.new(name: 'three')
       results = ProxyTestClass.foo
 
@@ -83,6 +77,19 @@ describe Daylight::ResourceProxy do
     it "supported through Enumerable methods" do
       ProxyTestClass.foo.map {|f| f.name}.should == %w[one two]
     end
+
+    it "pulls the first off of the array if it's already loaded" do
+      result = ProxyTestClass.foo
+      result.instance_variable_set('@records', [:yay, :boo])
+
+      result.first.should == :yay
+    end
+
+    it "does a request for first if it hasn't been loaded" do
+      result = ProxyTestClass.foo
+
+      result.first.name.should == 'one'
+    end
   end
 
   describe "results fetch" do

data/spec/rails/daylight/api_controller_spec.rb

@@ -14,7 +14,7 @@ class SuitesController < Daylight::APIController
 
   private
     def suite_params
-      params.require(:suite).permit(:name, :switch)
+      params.fetch(:suite, {}).permit(:name, :switch)
     end
 end
 

data/spec/rails/extensions/nested_attributes_ext_spec.rb

@@ -6,8 +6,9 @@ class NoNestedAttributesTest < ActiveRecord::Base; end
 # test cyclic autosave problem that AutosaveAssociataionFix resolves
 class NestedAttributeTest < ActiveRecord::Base
   has_many :collection, class_name: 'AssocNestedAttributeTest', inverse_of: :nested_attribute_test
+  has_many :through_collection, class_name: 'SingleNestedAttributeTest', through: :collection, source: :single_nested_attribute_test
 
-  accepts_nested_attributes_for :collection
+  accepts_nested_attributes_for :collection, :through_collection
 end
 
 class SingleNestedAttributeTest < ActiveRecord::Base
@@ -23,6 +24,16 @@ class AssocNestedAttributeTest < ActiveRecord::Base
   accepts_nested_attributes_for :nested_attribute_test, :single_nested_attribute_test
 end
 
+class HabtmParentNestedAttributeTest < ActiveRecord::Base
+  has_and_belongs_to_many :foo, class_name: 'HabtmChildNestedAttributeTest'
+
+  accepts_nested_attributes_for :foo
+end
+
+class HabtmChildNestedAttributeTest < ActiveRecord::Base
+  has_and_belongs_to_many :foo, class_name: 'HabtmParentNestedAttributeTest'
+end
+
 describe NestedAttributesExt, type: [:model] do
 
   migrate do
@@ -39,6 +50,19 @@ describe NestedAttributesExt, type: [:model] do
       t.references :nested_attribute_test
       t.references :single_nested_attribute_test
     end
+
+    create_table :habtm_parent_nested_attribute_tests do |t|
+      t.string :name
+    end
+
+    create_table :habtm_child_nested_attribute_tests do |t|
+      t.string :name
+    end
+
+    create_table :habtm_child_nested_attribute_tests_parent_nested_attribute_tests do |t|
+      t.belongs_to :habtm_parent_nested_attribute_test
+      t.belongs_to :habtm_child_nested_attribute_test
+    end
   end
 
   before(:all) do
@@ -54,6 +78,14 @@ describe NestedAttributesExt, type: [:model] do
       factory :assoc_nested_attribute_test do
         name { Faker::Name.name }
       end
+
+      factory :habtm_child_nested_attribute_test do
+        name { Faker::Name.name }
+      end
+
+      factory :habtm_parent_nested_attribute_test do
+        name { Faker::Name.name }
+      end
     end
   end
 
@@ -77,101 +109,171 @@ describe NestedAttributesExt, type: [:model] do
   end
 
 
-  describe 'has_many' do
-    let(:record) { create(:nested_attribute_test) }
-    let(:member) { create(:assoc_nested_attribute_test) }
+  describe 'associate' do
 
-    it "ignores nil values" do
-      record.collection_attributes = nil
+    describe 'has_many' do
+      let(:record) { create(:nested_attribute_test) }
+      let(:member) { create(:assoc_nested_attribute_test) }
 
-      lambda { record.save! }.should_not raise_error
-      record.collection.should == []
-    end
+      it "ignores nil values" do
+        record.collection_attributes = nil
 
-    it "continues to create and associate new records" do
-      record.collection_attributes = [{name: 'foo'}, {name: 'bar'}]
+        lambda { record.save! }.should_not raise_error
+        record.collection.should == []
+      end
 
-      lambda { record.save! }.should_not raise_error
+      it "continues to create and associate new records" do
+        record.collection_attributes = [{name: 'foo'}, {name: 'bar'}]
 
-      names = record.collection.map(&:name)
-      names.should include('foo')
-      names.should include('bar')
-    end
+        lambda { record.save! }.should_not raise_error
 
-    it "continues to update assoicated records" do
-      record.collection << member
-      record.collection_attributes = [{id: member.id, name: 'Foozle Cumberbunch'}]
+        names = record.collection.map(&:name)
+        names.should include('foo')
+        names.should include('bar')
+      end
 
-      lambda { record.save! }.should_not raise_error
-      record.collection.size.should == 1
-      record.collection.first.name.should == 'Foozle Cumberbunch'
-    end
+      it "continues to update assoicated records" do
+        record.collection << member
+        record.collection_attributes = [{id: member.id, name: 'Foozle Cumberbunch'}]
+
+        lambda { record.save! }.should_not raise_error
+        record.collection.size.should == 1
+        record.collection.first.name.should == 'Foozle Cumberbunch'
+      end
 
-    # this also tests cyclic autosave problem that AutosaveAssociataionFix resolves
-    it "associates existing records" do
-      record.collection_attributes = [{id: member.id}]
+      # this also tests cyclic autosave problem that AutosaveAssociataionFix resolves
+      it "associates existing records" do
+        record.collection_attributes = [{id: member.id}]
 
-      lambda { record.save! }.should_not raise_error
-      record.collection.size.should == 1
-      record.collection.first.id.should == member.id
+        lambda { record.save! }.should_not raise_error
+        record.collection.size.should == 1
+        record.collection.first.id.should == member.id
+      end
+
+      # this also tests cyclic autosave problem that AutosaveAssociataionFix resolves
+      it "keeps association for existing records that are already assoicated" do
+        record.collection << member
+        record.collection_attributes = [{id: member.id}]
+
+        lambda { record.save! }.should_not raise_error
+        record.collection.size.should == 1
+        record.collection.first.id.should == member.id
+      end
+
+      it "updates records that were just associated" do
+        record.collection_attributes = [{id: member.id, name: 'Foozle Cumberbunch'}]
+
+        lambda { record.save! }.should_not raise_error
+        record.collection.size.should == 1
+        record.collection.first.name.should == 'Foozle Cumberbunch'
+      end
+
+      it "ignores foreign key updates" do
+        different_foreign_key = record.id + 1
+        record.collection_attributes = [{id: member.id, name: 'Foozle Cumberbunch', nested_attribute_test_id: different_foreign_key}]
+
+        lambda { record.save! }.should_not raise_error
+
+        record.collection.size.should == 1
+        record.collection.first.nested_attribute_test_id.should == record.id
+      end
+
+      # this also tests cyclic autosave problem that AutosaveAssociataionFix resolves
+      it "updates previsoulsy associated records" do
+        record.collection << member
+
+        lambda { record.update!(collection_attributes: [{id: member.id, name: 'Foozle Cumberbunch'}]) }.should_not raise_error
+
+        record.collection.size.should == 1
+        record.collection.first.name.should == 'Foozle Cumberbunch'
+      end
     end
 
-    # this also tests cyclic autosave problem that AutosaveAssociataionFix resolves
-    it "keeps association for existing records that are already assoicated" do
-      record.collection << member
-      record.collection_attributes = [{id: member.id}]
+    describe 'has_one' do
+      let(:record) { create(:single_nested_attribute_test) }
+      let(:member) { create(:assoc_nested_attribute_test) }
 
-      lambda { record.save! }.should_not raise_error
-      record.collection.size.should == 1
-      record.collection.first.id.should == member.id
+      it "ignores nil values" do
+        record.single = nil
+
+        lambda { record.save! }.should_not raise_error
+        record.single.should be_nil
+      end
+
+      it "continues to create and associate new records" do
+        record.single_attributes = {name: 'wibble'}
+
+        lambda { record.save! }.should_not raise_error
+
+        record.single.name.should == 'wibble'
+      end
     end
+  end
 
-    it "updates records that were just associated" do
-      record.collection_attributes = [{id: member.id, name: 'Foozle Cumberbunch'}]
+  describe 'unassociating records missing from the attributes collection' do
 
-      lambda { record.save! }.should_not raise_error
-      record.collection.size.should == 1
-      record.collection.first.name.should == 'Foozle Cumberbunch'
+    let(:single1) { create(:single_nested_attribute_test) }
+    let(:single2) { create(:single_nested_attribute_test) }
+    let(:assoc1) do
+      create(:assoc_nested_attribute_test) {|record| record.single_nested_attribute_test = single1 }
+    end
+    let(:assoc2) do
+      create(:assoc_nested_attribute_test) {|record| record.single_nested_attribute_test = single2 }
     end
 
-    it "ignores foreign key updates" do
-      different_foreign_key = record.id + 1
-      record.collection_attributes = [{id: member.id, name: 'Foozle Cumberbunch', nested_attribute_test_id: different_foreign_key}]
+    let(:record) do
+      record = create(:nested_attribute_test) {|r| r.collection = [assoc1, assoc2] }
+    end
+
+    it 'handles has_many relationships' do
+      record.collection_attributes = [assoc2.as_json]
 
       lambda { record.save! }.should_not raise_error
 
-      record.collection.size.should == 1
-      record.collection.first.nested_attribute_test_id.should == record.id
+      record.reload.collection.map(&:id).should == [assoc2.id]
+
+      assoc1.reload.nested_attribute_test.should be_nil
+      assoc2.reload.nested_attribute_test.should == record
     end
 
-    # this also tests cyclic autosave problem that AutosaveAssociataionFix resolves
-    it "updates previsoulsy associated records" do
-      record.collection << member
+    it 'ignores has_many through' do
+      assoc2.single_nested_attribute_test.id.should == single2.id
+
+      record.through_collection.count.should == 2
 
-      lambda { record.update!(collection_attributes: [{id: member.id, name: 'Foozle Cumberbunch'}]) }.should_not raise_error
+      record.through_collection_attributes = [single1.as_json]
 
-      record.collection.size.should == 1
-      record.collection.first.name.should == 'Foozle Cumberbunch'
+      lambda { record.save! }.should_not raise_error
+
+      record.reload.through_collection.count.should == 2
     end
-  end
 
-  describe 'has_one' do
-    let(:record) { create(:single_nested_attribute_test) }
-    let(:member) { create(:assoc_nested_attribute_test) }
+    it 'ignores habtm' do
+      test = create(:habtm_parent_nested_attribute_test)
+      test.foo << create(:habtm_child_nested_attribute_test)
+      test.foo << create(:habtm_child_nested_attribute_test)
+      test.save!
+
+      test.reload.foo.count.should == 2
 
-    it "ignores nil values" do
-      record.single = nil
+      test.foo_attributes = [test.foo.first.as_json]
 
       lambda { record.save! }.should_not raise_error
-      record.single.should be_nil
+
+      test.reload.foo.count.should == 2
     end
 
-    it "continues to create and associate new records" do
-      record.single_attributes = {name: 'wibble'}
+    it 'allows removing all things from a collection' do
+      record.collection_attributes = []
 
       lambda { record.save! }.should_not raise_error
 
-      record.single.name.should == 'wibble'
+      record.reload.collection.should be_empty
+
+      assoc1.reload.nested_attribute_test.should be_nil
+      assoc2.reload.nested_attribute_test.should be_nil
     end
+
   end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daylight
 version: !ruby/object:Gem::Version
-  version: 0.9.0.rc2
+  version: 0.9.0.rc3
 platform: ruby
 authors:
 - Reid MacDonald
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-30 00:00:00.000000000 Z
+date: 2014-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activeresource
@@ -224,6 +224,7 @@ files:
 - config/routes.rb
 - lib/daylight.rb
 - lib/daylight/api.rb
+- lib/daylight/association_persistance.rb
 - lib/daylight/associations.rb
 - lib/daylight/client_reloader.rb
 - lib/daylight/collection.rb
@@ -308,6 +309,7 @@ files:
 - spec/dummy/public/favicon.ico
 - spec/helpers/documentation_helper_spec.rb
 - spec/lib/daylight/api_spec.rb
+- spec/lib/daylight/association_persistance_spec.rb
 - spec/lib/daylight/associations_spec.rb
 - spec/lib/daylight/collection_spec.rb
 - spec/lib/daylight/errors_spec.rb
@@ -398,6 +400,7 @@ test_files:
 - spec/dummy/public/favicon.ico
 - spec/helpers/documentation_helper_spec.rb
 - spec/lib/daylight/api_spec.rb
+- spec/lib/daylight/association_persistance_spec.rb
 - spec/lib/daylight/associations_spec.rb
 - spec/lib/daylight/collection_spec.rb
 - spec/lib/daylight/errors_spec.rb