embedded_associations 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - 1.9.3
+before_install:
+  - gem install bundler --version '>= 1.2.2'
+script: "bundle exec rspec"

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rails', '3.2.12'
+  gem 'sqlite3'
+  gem 'active_model_serializers'
+
+  gem 'rspec'
+  gem 'rspec-rails'
+
+  gem 'pry'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Gordon L. Hempton
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+# EmbeddedAssociations
+
+Provides ActionController-level support for embedded associations in Rails. Use cases include:
+
+* Being able to easily consume embedded records serialized from [Active Model Serializers](https://github.com/rails-api/active_model_serializers).
+* Simplifying REST API implementations.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'embedded_associations'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install embedded_associations
+
+## Usage
+
+Embedded Associations provides an `embedded_association` macro to ActionController:
+
+```ruby
+class PostsController < ApplicationController
+  embedded_association :tags
+  embedded_association :comments => :user
+end
+```
+
+Behind the scenes, this will make the controller parse out sub-params passed in and perform the necessary ActiveRecord model manipulation. E.g., consider the params hash below:
+
+```ruby
+{
+  post: {
+    tags: ['rest', 'ember-data'],
+    comments: [
+      {user: {name: 'Gordon'}}
+    ]
+  }
+}
+```
+
+Based on the declared `embedded_association`s, the controller will manipulate the `tags` and `comments` association to reflect the passed in params (including deleting or creating child records).
+
+### Controller and Model Pre-Requisites
+
+EmbeddedAssociations depends on your controller implementation to have two methods available, `resource` and `resource_name`. These methods will be familiar and already provided to people who use [CanCan's](https://github.com/ryanb/cancan) `load_resource` macro.
+
+When defining the relationships in the model, it is also important to set the `autosave` and `dependent` options on the association:
+
+```ruby
+class Post < ActiveRecord::Base
+  has_many :comments, autosave: true, dependent: :destroy
+  has_many :tags, autosave: true, dependent: :destroy
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/embedded_associations.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'embedded_associations/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "embedded_associations"
+  gem.version       = EmbeddedAssociations::VERSION
+  gem.authors       = ["Gordon L. Hempton"]
+  gem.email         = ["ghempton@gmail.com"]
+  gem.description   = %q{ActiveRecord controller-level support for embedded associations}
+  gem.summary       = %q{ActiveRecord controller-level support for embedded associations}
+  gem.homepage      = "https://github.com/GroupTalent/embedded_associations"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "railties", "> 3.0.0"
+end

data/lib/embedded_associations.rb

@@ -0,0 +1,165 @@
+require "embedded_associations/rails"
+require "embedded_associations/version"
+
+module EmbeddedAssociations
+
+  def self.included(base)
+    base.instance_eval do
+
+      class_attribute :embedded_associations
+
+      def self.embedded_association(definition)
+        unless embedded_associations
+          self.embedded_associations = Definitions.new
+          before_filter :handle_embedded_associations, only: [:update, :create, :destroy]
+        end
+        self.embedded_associations = embedded_associations.add_definition(definition)
+      end
+    end
+  end
+
+  def handle_embedded_associations
+    Processor.new(embedded_associations, self).run
+  end
+
+  def root_resource
+    resource
+  end
+
+  def root_resource_name
+    resource_name
+  end
+
+  # Simple callbacks for now, eventually should use a filter system
+  def before_embedded_update(record); end
+  def before_embedded_create(record); end
+  def before_embedded_destroy(record); end
+
+  class Definitions
+    include Enumerable
+
+    attr_accessor :definitions
+
+    def initialize
+      @definitions = []
+    end
+
+    # Keep immutable to prevent all controllers
+    # from sharing the same copy
+    def add_definition(definition)
+      result = self.dup
+      result.definitions << definition
+      result
+    end
+
+    def initialize_copy(source)
+      self.definitions = source.definitions.dup
+    end
+
+    def each(&block)
+      self.definitions.each &block
+    end
+  end
+
+  class Processor
+
+    attr_reader :definitions
+    attr_reader :controller
+
+    def initialize(definitions, controller)
+      @definitions = definitions
+      @controller = controller
+    end
+
+    def run
+      definitions.each do |definition|
+        handle_resource(definition, controller.root_resource, controller.params[controller.root_resource_name])
+      end
+    end
+
+    private
+
+    # Definition can be either a name, array, or hash.
+    def handle_resource(definition, parent, parent_params)
+      if definition.is_a? Array
+        return definition.each{|d| handle_resource(d, parent, parent_params)}
+      end
+      # normalize to a hash
+      unless definition.is_a? Hash
+        definition = {definition => nil}
+      end
+
+      definition.each do |name, child_definition|
+        binding.pry unless parent
+        reflection = parent.class.reflect_on_association(name)
+        attrs = parent_params && parent_params.delete(name.to_s)
+        
+        if reflection.collection?
+          attrs ||= []
+          handle_plural_resource parent, name, attrs, child_definition
+        else
+          handle_singular_resource parent, name, attrs, child_definition
+        end
+      end
+    end
+
+    def handle_plural_resource(parent, name, attr_array, child_definition)
+      current_assoc = parent.send(name)
+
+      # Mark non-existant records as deleted
+      current_assoc.select{|r| attr_array.none?{|attrs| attrs['id'] && attrs['id'].to_i == r.id}}.each do |r|
+        handle_resource(child_definition, r, nil) if child_definition
+        run_before_destroy_callbacks(r)
+        r.mark_for_destruction
+      end
+
+      attr_array.each do |attrs|
+        if id = attrs['id']
+          # can't use current_assoc.find(id), see http://stackoverflow.com/questions/11605120/autosave-ignored-on-has-many-relation-what-am-i-missing
+          r = current_assoc.find{|r| r.id == id.to_i}
+          handle_resource(child_definition, r, attrs) if child_definition
+          r.assign_attributes(attrs)
+          run_before_update_callbacks(r)
+        else
+          r = current_assoc.build()
+          handle_resource(child_definition, r, attrs) if child_definition
+          r.assign_attributes(attrs)
+          run_before_create_callbacks(r)
+        end
+      end
+    end
+
+    def handle_singular_resource(parent, name, attrs, child_definition)
+      current_assoc = parent.send(name)
+      if r = current_assoc
+        if attrs
+          handle_resource(child_definition, r, attrs) if child_definition
+          r.assign_attributes(attrs)
+          run_before_update_callbacks(r)
+        else
+          handle_resource(child_definition, r, attrs) if child_definition
+          run_before_destroy_callbacks(r)
+          r.mark_for_destruction
+        end
+      elsif attrs
+        r = parent.send("build_#{name}")
+        handle_resource(child_definition, r, attrs) if child_definition
+        r.assign_attributes(attrs)
+        run_before_create_callbacks(r)
+      end
+    end
+
+    def run_before_create_callbacks(record)
+      controller.send(:before_embedded_create, record)
+    end
+
+    def run_before_update_callbacks(record)
+      controller.send(:before_embedded_update, record)
+    end
+
+    def run_before_destroy_callbacks(record)
+      controller.send(:before_embedded_destroy, record)
+    end
+  end
+
+end

data/lib/embedded_associations/rails.rb

@@ -0,0 +1,13 @@
+require 'rails'
+
+module EmbeddedAssociations
+
+  class Engine < ::Rails::Engine
+    initializer "embedded_associations" do
+      ActiveSupport.on_load(:action_controller) do
+        include EmbeddedAssociations
+      end
+    end
+  end
+
+end

data/lib/embedded_associations/version.rb

@@ -0,0 +1,3 @@
+module EmbeddedAssociations
+  VERSION = "0.0.1"
+end

data/spec/embedded_associations_spec.rb

@@ -0,0 +1,324 @@
+require 'spec_helper'
+
+describe PostsController, type: :controller do
+  include SerializationHelpers
+
+  describe "embedded has_many" do
+
+    context "creating" do
+
+      it "should create child records" do
+        json = post :create, post: {
+          tags: [{},{}]
+        }
+
+        expect(Post.count).to eq(1)
+        expect(Tag.count).to eq(2)
+
+        Tag.all.each{ |t| expect(t.post).to_not be_nil }
+      end
+
+    end
+
+    context "updating" do
+
+      let(:tags) {[Tag.create, Tag.create]}
+      let(:resource) { Post.create({tags: tags}, without_protection: true) }
+      let(:hash) { serialize(resource) }
+
+      it "should create new child records" do
+        hash[:tags] += [{},{}]
+        json = post :update, :id => resource.id, post: hash
+
+        expect(Post.count).to eq(1)
+        expect(Tag.count).to eq(4)
+
+        Tag.all.each{ |t| expect(t.post).to_not be_nil }
+      end
+
+      it "should destroy missing child records" do
+        hash[:tags] = hash[:tags].take(1)
+        json = post :update, :id => resource.id, post: hash
+
+        expect(Post.count).to eq(1)
+        expect(Tag.count).to eq(1)
+
+        Tag.all.each{ |t| expect(t.post).to_not be_nil }
+      end
+
+      it "should update modified child records" do
+        hash[:tags].first[:name] = 'modified'
+        json = post :update, :id => resource.id, post: hash
+
+        expect(Post.count).to eq(1)
+        expect(Tag.count).to eq(2)
+
+        expect(Tag.first.name).to eq('modified')
+
+        Tag.all.each{ |t| expect(t.post).to_not be_nil }
+      end
+
+    end
+
+  end
+
+  describe "embedded belongs_to" do
+
+    context "creating" do
+
+      it "should create child record" do
+        json = post :create, post: {
+          category: {name: 'ember-data'}
+        }
+
+        expect(Post.count).to eq(1)
+        expect(Category.count).to eq(1)
+
+        resource = Post.first
+
+        expect(resource.category).to_not be_nil
+      end
+
+    end
+
+    context "updating" do
+
+      let(:resource) { Post.create }
+      let(:hash) { serialize(resource) }
+
+      it "should create new child record" do
+        hash[:category] = {name: 'ember'}
+        json = post :update, :id => resource.id, post: hash
+
+        expect(Post.count).to eq(1)
+        expect(Category.count).to eq(1)
+
+        resource.reload
+
+        expect(resource.category).to_not be_nil
+      end
+
+      context do
+
+        let(:resource) { Post.create({category: Category.create(name: 'ember')}, without_protection: true) }
+
+        it "should destroy nil child record" do
+          hash[:category] = nil
+          json = post :update, :id => resource.id, post: hash
+
+          expect(Post.count).to eq(1)
+          expect(Category.count).to eq(0)
+
+          resource.reload
+
+          expect(resource.category).to be_nil
+        end
+
+        it "should update modified child records" do
+          hash[:category][:name] = 'ember-data'
+          json = post :update, :id => resource.id, post: hash
+
+          resource.reload
+
+          expect(resource.category.name).to eq('ember-data')
+        end
+
+      end
+    end
+
+  end
+
+  describe "embedded belongs_to -> has_one" do
+
+    context "creating" do
+
+      it "should create hierarchy" do
+        json = post :create, post: {
+          user: {name: 'G$', account: {}}
+        }
+
+        expect(Post.count).to eq(1)
+        expect(User.count).to eq(1)
+        expect(Account.count).to eq(1)
+
+        resource = Post.first
+
+        expect(resource.user).to_not be_nil
+        expect(resource.user.account).to_not be_nil
+      end
+
+    end
+
+    context "updating" do
+
+      let(:resource) { Post.create }
+      let(:hash) { serialize(resource) }
+
+      it "should create new hierarchy" do
+        hash[:user] = {name: 'G$', account: {}}
+        json = post :update, :id => resource.id, post: hash
+
+        expect(User.count).to eq(1)
+        expect(Account.count).to eq(1)
+
+        resource.reload
+
+        expect(resource.user).to_not be_nil
+        expect(resource.user.account)
+      end
+
+      context do
+
+        let(:resource) { Post.create({user: User.create({name: 'G$', account: Account.create}, without_protection: true)}, without_protection: true) }
+
+        it "should destroy nil child hierarchy" do
+          hash[:user] = nil
+          json = post :update, :id => resource.id, post: hash
+
+          expect(Post.count).to eq(1)
+          expect(User.count).to eq(0)
+          expect(Account.count).to eq(0)
+
+          resource.reload
+
+          expect(resource.user).to be_nil
+        end
+
+        it "should destroy nil grand-child" do
+          hash[:user] = {name: 'G$'}
+          json = post :update, :id => resource.id, post: hash
+
+          expect(Post.count).to eq(1)
+          expect(User.count).to eq(1)
+          expect(Account.count).to eq(0)
+
+          resource.reload
+
+          expect(resource.user.account).to be_nil
+        end
+
+        it "should update modified child records" do
+          hash[:user][:name] = 'wes'
+          hash[:user][:account][:note] = 'test'
+          json = post :update, :id => resource.id, post: hash
+
+          resource.reload
+
+          expect(resource.user.name).to eq('wes')
+          expect(resource.user.account.note).to eq('test')
+        end
+
+        it "should update modified grand-child" do
+          hash[:user][:account][:note] = 'test'
+          json = post :update, :id => resource.id, post: hash
+
+          resource.reload
+
+          expect(resource.user.account.note).to eq('test')
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "embedded has_many -> belongs_to -> has_one" do
+
+    context "creating" do
+
+      it "should create hierarchy" do
+        json = post :create, post: {
+          comments: [{user: {name: 'G$', account: {}}}]
+        }
+
+        expect(Post.count).to eq(1)
+        expect(Comment.count).to eq(1)
+        expect(User.count).to eq(1)
+        expect(Account.count).to eq(1)
+
+        resource = Post.first
+
+        expect(resource.comments).to_not be_empty
+        expect(resource.comments.first.user).to_not be_nil
+        expect(resource.comments.first.user.account).to_not be_nil
+      end
+
+    end
+
+    context "updating" do
+
+      let(:resource) { Post.create }
+      let(:hash) { serialize(resource) }
+
+      it "should create new hierarchy" do
+        hash[:comments] = [{user: {name: 'G$', account: {}}}]
+        json = post :update, :id => resource.id, post: hash
+
+        expect(Comment.count).to eq(1)
+        expect(User.count).to eq(1)
+        expect(Account.count).to eq(1)
+
+        resource.reload
+
+        expect(resource.comments).to_not be_empty
+        expect(resource.comments.first.user).to_not be_nil
+        expect(resource.comments.first.user.account).to_not be_nil
+      end
+
+      context do
+
+        let(:resource) {
+          p = Post.create
+          c = p.comments.create
+          u = c.create_user({account: Account.create}, without_protection: true)
+          c.save
+          p
+        }
+
+        it "should destroy nil child hierarchy" do
+          hash[:comments] = nil
+          json = post :update, :id => resource.id, post: hash
+
+          expect(Post.count).to eq(1)
+          expect(Comment.count).to eq(0)
+          expect(User.count).to eq(0)
+          expect(Account.count).to eq(0)
+
+          resource.reload
+
+          expect(resource.comments).to be_empty
+        end
+
+        it "should destroy nil grand-child hierarchy" do
+          hash[:comments].first[:user] = nil
+          json = post :update, :id => resource.id, post: hash
+
+          expect(Post.count).to eq(1)
+          expect(Comment.count).to eq(1)
+          expect(User.count).to eq(0)
+          expect(Account.count).to eq(0)
+
+          resource.reload
+
+          expect(resource.comments.first.user).to be_nil
+        end
+
+        it "should update modified child records" do
+          hash[:comments].first[:user][:name] = 'wes'
+          hash[:comments].first[:user][:account][:note] = 'test'
+          json = post :update, :id => resource.id, post: hash
+
+          resource.reload
+
+          expect(resource.comments.first.user.name).to eq('wes')
+          expect(resource.comments.first.user.account.note).to eq('test')
+        end
+
+      end
+
+    end
+
+  end
+
+end