Initial stab at recursive sideloading

Implementation idea for sideloading to help out JS Frameworks

Implementation idea for sideloading to help out JS Frameworks

added tests for sideloading and binding.pry for debugging

added configuration option for sideloading associations

switching computers

tests pass

revert require of dev-friendly gems - as they aren't as compatible as AMS is aiming to be

also fixed a bug introduced by the sideloading - no existing tests caught the bug before initial push

added a test for has_one

Why does steve show up twice

be more explicit about what gets added to the associations

all tests passing

minor renaming refactor

remove gemfile.local

Author: NullVoxPopuli

Gemfile

@@ -33,3 +33,10 @@ end
 
 # Windows does not include zoneinfo files, so bundle the tzinfo-data gem
 gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw, :jruby]
+
+
+# Add a Gemfile.local to locally bundle gems outside of version control
+local_gemfile = File.join(File.expand_path("..", __FILE__), "Gemfile.local")
+if File.readable?(local_gemfile)
+  eval_gemfile local_gemfile
+end

active_model_serializers.gemspec

@@ -47,4 +47,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'timecop', '>= 0.7'
+
 end

lib/active_model/serializer/adapter.rb

@@ -4,6 +4,7 @@ class Adapter
       extend ActiveSupport::Autoload
       require 'active_model/serializer/adapter/json'
       require 'active_model/serializer/adapter/json_api'
+      require 'active_model/serializer/adapter/json_sideload'
       autoload :FlattenJson
       autoload :Null
       autoload :FragmentCache
@@ -86,7 +87,11 @@ def meta_key
       end
 
       def root
-        serializer.json_key.to_sym if serializer.json_key
+        if serializer.json_key
+          serializer.json_key.to_sym
+        else
+          serializer.root
+        end
       end
 
       def include_meta(json)

lib/active_model/serializer/adapter/json_sideload.rb

@@ -0,0 +1,187 @@
+module ActiveModel
+  class Serializer
+    class Adapter
+      class JsonSideload < Json
+
+        # the list of what has already been serialized will be kept here to
+        # help avoid infinite recursion
+        #
+        # this should be a list of association_name to a list of objects
+        attr_accessor :serialized
+
+        # When we are sideloading associations, we can more easily track what
+        # has been serialized, so that we avoid infinite
+        # recursion / serialization.
+        def initialize(*args)
+          @serialized = {}
+
+          super(*args)
+        end
+
+        def serializable_hash(options = nil)
+          options ||= {}
+
+          serialize_hash(options)
+
+          singularize_lone_objects
+
+          @serialized
+        end
+
+
+        def serialize_hash(options)
+          result = nil
+
+          if serializer.respond_to?(:each)
+            #TODO: Is this ever hit?
+            # binding.pry
+            ap "wwwwwwwwwwwwwwwwwwwwww"
+            result = serialize_array(serializer, options)
+          else
+            # skip if we are already serialized
+            key_name = serializer.object.class.name.tableize
+            existing_of_kind = @serialized[key_name]
+            exists = existing_of_kind ? existing_of_kind.select{|a| a[:id] == s.object.id } : false
+            return if exists
+
+            # we aren't an array! woo!
+
+            result = serialized_attributes_of(serializer, options)
+            # add to the list of the serialized
+
+
+            # now, go over our associations, and add them to the master
+            # serialized hash
+            serializer.associations.each do |association|
+              serializer = association.serializer
+              opts = association.options
+
+              # make sure the association key exists in the master
+              # serialized hash
+              @serialized[association.key] ||= []
+
+              if serializer.respond_to?(:each)
+                array = serialize_array(serializer, opts)
+                association_list = @serialized[association.key]
+
+
+                array.each do |item|
+                  if not association_list.include?(item)
+                    association_list << item
+                  end
+                end
+                @serialized[association.key] = association_list
+
+                # add the ids to the result
+                result[ids_name_for(association.key)] = array.map{|a| a[:id] }
+              else
+                hash = (
+                  if serializer && serializer.object
+                    serialized_attributes_of(serializer, options)
+                  elsif opts[:virtual_value]
+                    opts[:virtual_value]
+                  end
+                )
+
+                add(association.key, hash)
+
+                # add the id to the result
+                result[id_name_for(association.key)] = hash[:id]
+              end
+
+            end
+          end
+
+          @serialized[key_name] ||= []
+          add(key_name, result)
+
+          result
+        end
+
+        def add(key, data)
+          unless associations_contain?(data, key)
+            if @serialized[key].is_a?(Hash)
+              # make array
+              value = @serialized[key]
+              @serialized[key] = [value, data]
+            else
+              # already is array
+              @serialized[key] << data
+            end
+          end
+        end
+
+        def serialize_array(serializer, options)
+          array = serializer.map { |s|
+            js = JsonSideload.new(s)
+            serialized = js.serialize_hash(options)
+
+            # keep the associations up to date
+            append_to_serialized(js.serialized)
+
+            serialized
+          }
+
+          # remove nils
+          array.compact
+        end
+
+        def ids_name_for(name)
+          id_name_for(name).to_s.pluralize.to_sym
+        end
+
+        def id_name_for(name)
+          name.to_s.singularize.foreign_key.to_sym
+        end
+
+
+        def serialized_attributes_of(item, options)
+          cache_check(item) do
+            item.attributes(options)
+          end
+        end
+
+        def singularize_lone_objects
+          temp = {}
+
+          @serialized.each do |key, data|
+            if data.length > 1
+              temp[key.to_s.pluralize.to_sym] = data
+            else
+              temp[key.to_s.singularize.to_sym] = data.first
+            end
+          end
+
+          @serialized = temp
+        end
+
+        def append_to_serialized(serialized_objects)
+          serialized_objects ||= {}
+
+          serialized_objects.each do |association_name, data|
+            @serialized[association_name] ||= []
+
+            if data.is_a?(Array)
+              data.each do |sub_data|
+                append_to_serialized(association_name => sub_data)
+              end
+            else
+              unless associations_contain?(data, association_name)
+                add(association_name, data)
+              end
+            end
+          end
+
+          @serialized
+        end
+
+        def associations_contain?(item, key)
+          return false if @serialized[key].nil?
+
+          @serialized[key] == item || @serialized[key].include?(item)
+        end
+
+      end
+    end
+  end
+end

lib/active_model/serializer/configuration.rb

@@ -8,6 +8,7 @@ module Configuration
         base.config.array_serializer = ActiveModel::Serializer::ArraySerializer
         base.config.adapter = :flatten_json
         base.config.jsonapi_resource_type = :plural
+        base.config.sideload_associations = false
       end
     end
   end

test/adapter/json/sideload_test.rb

@@ -0,0 +1,105 @@
+require 'test_helper'
+
+class ParentBlog < Blog; end
+class ParentBlogSerializer < BlogSerializer; end
+class HasOnePostSerializer < PostSerializer
+  attributes :id, :title, :body
+
+  has_many :comments
+  belongs_to :blog
+  belongs_to :author
+  has_one :parent_blog
+  url :comments
+end
+
+module ActiveModel
+  class Serializer
+    class Adapter
+      class Json
+        class SideloadTestTest < Minitest::Test
+          def setup
+            # ActiveModel::Serializer.config.sideload_associations = true
+            ActionController::Base.cache_store.clear
+            @author = Author.new(id: 1, name: 'Steve K.')
+            @post = Post.new(id: 42, title: 'New Post', body: 'Body')
+            @first_comment = Comment.new(id: 1, body: 'ZOMG A COMMENT', author: @author)
+            @second_comment = Comment.new(id: 2, body: 'ZOMG ANOTHER COMMENT', author: @author)
+            @post.comments = [@first_comment, @second_comment]
+            @post.author = @author
+            @first_comment.post = @post
+            @second_comment.post = @post
+            @blog = Blog.new(id: 1, name: "My Blog!!")
+            @parent_blog = ParentBlog.new(id: 2, name: "Parent Blog!!")
+            @post.blog = @blog
+            @post.parent_blog = @parent_blog
+            @tag = Tag.new(id: 1, name: "#hash_tag")
+            @post.tags = [@tag]
+          end
+
+          def teardown
+            # ActiveModel::Serializer.config.sideload_associations = false
+          end
+
+          def test_associations_not_present_in_base_model
+            serializer = PostSerializer.new(@post)
+            adapter = ActiveModel::Serializer::Adapter::JsonSideload.new(serializer)
+
+            assert_equal(nil, adapter.serializable_hash[:post][:comments])
+          end
+
+          def test_associations_replaced_with_association_ids
+            serializer = PostSerializer.new(@post)
+            adapter = ActiveModel::Serializer::Adapter::JsonSideload.new(serializer)
+            assert_equal([1, 2], adapter.serializable_hash[:post][:comment_ids])
+          end
+
+          def test_relevant_associated_objects_in_json_root
+            serializer = PostSerializer.new(@post)
+            adapter = ActiveModel::Serializer::Adapter::JsonSideload.new(serializer)
+            assert_equal([
+              {:id=>1, :body=>"ZOMG A COMMENT", :post_id=>42, :author_id=>1},
+              {:id=>2, :body=>"ZOMG ANOTHER COMMENT", :post_id=>42, :author_id=>1}
+                         ], adapter.serializable_hash[:comments])
+          end
+
+          def test_has_one_has_a_singular_key
+            serializer = HasOnePostSerializer.new(@post)
+            adapter = ActiveModel::Serializer::Adapter::JsonSideload.new(serializer)
+
+            assert_equal({
+                id: 2, name: "Parent Blog!!"
+              }, adapter.serializable_hash[:parent_blog])
+          end
+
+          def test_belongs_to_has_a_singular_key
+            serializer = PostSerializer.new(@post)
+            adapter = ActiveModel::Serializer::Adapter::JsonSideload.new(serializer)
+            assert_equal({
+                id: 1, name: "Steve K."
+              }, adapter.serializable_hash[:author])
+          end
+
+          def test_append_to_serialized
+            serializer = PostSerializer.new(@post)
+            adapter = ActiveModel::Serializer::Adapter::JsonSideload.new(serializer)
+
+            adapter.serialized = {
+              post: { id: 1 },
+              comments: [{id: 1}]
+            }
+
+            result = adapter.append_to_serialized({
+              comments: [{id: 2}]
+            })
+
+            assert_equal({
+                post: { id: 1 },
+                comments: [{id: 1}, {id: 2}]
+              }, result)
+
+          end
+        end
+      end
+    end
+  end
+end

test/serializers/configuration_test.rb

@@ -10,6 +10,11 @@ def test_array_serializer
       def test_default_adapter
         assert_equal :flatten_json, ActiveModel::Serializer.config.adapter
       end
+
+      def test_default_sideload_associations
+        assert_equal false, ActiveModel::Serializer.config.sideload_associations
+      end
+
     end
   end
 end

test/test_helper.rb

@@ -7,6 +7,14 @@
 require 'action_controller/railtie'
 require 'active_support/json'
 require 'fileutils'
+
+begin
+  require 'awesome_print'
+  require 'pry-byebug'
+rescue LoadError => e
+  # not required for tests to run
+end
+
 FileUtils.mkdir_p(File.expand_path('../../tmp/cache', __FILE__))
 
 require 'minitest/autorun'