ivy-serializers 0.1.0

data/lib/ivy/serializers/formats.rb

@@ -0,0 +1,3 @@
+require 'ivy/serializers/formats/json'
+require 'ivy/serializers/formats/active_model_serializers'
+require 'ivy/serializers/formats/json_api'

data/lib/ivy/serializers/formats/active_model_serializers.rb

@@ -0,0 +1,40 @@
+require 'ivy/serializers/formats/json'
+
+module Ivy
+  module Serializers
+    module Formats
+      class ActiveModelSerializers < JSON
+        def belongs_to(name, resource, options={})
+          if options[:polymorphic]
+            if resource
+              @hash_gen.store_object(name) { polymorphic_resource(resource) }
+            else
+              @hash_gen.store(name, nil)
+            end
+          else
+            id(:"#{name}_id", resource)
+          end
+        end
+
+        def has_many(name, resources, options={})
+          if options[:polymorphic]
+            @hash_gen.store_array(name) { polymorphic_resources(resources) }
+          else
+            ids(:"#{ActiveSupport::Inflector.singularize(name.to_s)}_ids", resources)
+          end
+        end
+
+        private
+
+        def polymorphic_resource(resource)
+          id(:id, resource)
+          type(:type, resource)
+        end
+
+        def polymorphic_resources(resources)
+          resources.each { |resource| @hash_gen.push_object { polymorphic_resource(resource) } }
+        end
+      end
+    end
+  end
+end

data/lib/ivy/serializers/formats/json.rb

@@ -0,0 +1,96 @@
+require 'active_support/inflector'
+require 'hash_generator'
+
+module Ivy
+  module Serializers
+    module Formats
+      class JSON
+        def initialize(document)
+          @document = document
+          @hash_gen = HashGenerator.new
+        end
+
+        def as_json(*)
+          @document.generate(self)
+          @hash_gen.to_h
+        end
+
+        def attribute(key, value)
+          @hash_gen.store(key, value)
+        end
+
+        def belongs_to(name, resource, options={})
+          id(name, resource)
+        end
+
+        def document(document)
+          document.generate_primary_resource(self)
+          document.generate_linked(self)
+        end
+
+        def has_many(name, resources, options={})
+          ids(name, resources)
+        end
+
+        def id(key, resource)
+          attribute(key, extract_id(resource))
+        end
+
+        def ids(key, resources)
+          attribute(key, resources.map { |resource| extract_id(resource) })
+        end
+
+        def linked(document)
+          document.generate_linked_resources(self)
+        end
+
+        def linked_resources(resource_class, resources)
+          key = key_for_collection(resource_class).to_sym
+          @hash_gen.store_array(key) { resources(resources) }
+        end
+
+        def links(resource)
+          @document.generate_links(self, resource)
+        end
+
+        def primary_resource(primary_resource_name, primary_resource)
+          @hash_gen.store_object(primary_resource_name) { resource(primary_resource) }
+        end
+
+        def primary_resources(primary_resources_name, primary_resources)
+          @hash_gen.store_array(primary_resources_name) { resources(primary_resources) }
+        end
+
+        def resource(resource)
+          @document.generate_resource(self, resource)
+        end
+
+        def resources(resources)
+          resources.each { |resource| @hash_gen.push_object { resource(resource) } }
+        end
+
+        def type(key, resource)
+          attribute(key, extract_type(resource))
+        end
+
+        private
+
+        def extract_id(resource)
+          resource.id
+        end
+
+        def extract_type(resource)
+          ActiveSupport::Inflector.dasherize(ActiveSupport::Inflector.underscore(resource.class.name))
+        end
+
+        def key_for_collection(resource_class)
+          ActiveSupport::Inflector.pluralize(key_for_individual(resource_class))
+        end
+
+        def key_for_individual(resource_class)
+          ActiveSupport::Inflector.underscore(resource_class.name)
+        end
+      end
+    end
+  end
+end

data/lib/ivy/serializers/formats/json_api.rb

@@ -0,0 +1,66 @@
+require 'ivy/serializers/formats/json'
+
+module Ivy
+  module Serializers
+    module Formats
+      class JSONAPI < JSON
+        def attribute(key, value)
+          value = coerce_id(value) if key == :id
+          super
+        end
+
+        def belongs_to(name, resource, options={})
+          @hash_gen.store_object(name) { linkage(resource) }
+        end
+
+        def has_many(name, resources, options={})
+          @hash_gen.store_object(name) { linkages(resources) }
+        end
+
+        def linked(document)
+          @hash_gen.store_object(:included) { super }
+        end
+
+        def links(document)
+          @hash_gen.store_object(:links) { super }
+        end
+
+        def primary_resource(primary_resource_name, primary_resource)
+          @hash_gen.store_object(:data) { resource(primary_resource) }
+        end
+
+        def resource(resource)
+          super
+          type(:type, resource)
+        end
+
+        private
+
+        def coerce_id(id)
+          id.to_s
+        end
+
+        def extract_id(resource)
+          coerce_id(super)
+        end
+
+        def linkage(resource)
+          @hash_gen.store_object(:linkage) { linkage_object(resource) }
+        end
+
+        def linkage_object(resource)
+          id(:id, resource)
+          type(:type, resource)
+        end
+
+        def linkages(resources)
+          @hash_gen.store_array(:linkage) { linkage_objects(resources) }
+        end
+
+        def linkage_objects(resources)
+          resources.each { |resource| @hash_gen.push_object { linkage_object(resource) } }
+        end
+      end
+    end
+  end
+end

data/lib/ivy/serializers/mapping.rb

@@ -0,0 +1,40 @@
+require 'ivy/serializers/attribute'
+require 'ivy/serializers/relationships'
+
+module Ivy
+  module Serializers
+    class Mapping
+      def initialize(klass)
+        @attrs = {}
+        @links = {}
+        @klass = klass
+
+        attribute(:id)
+      end
+
+      def attribute(name, &block)
+        @attrs[name] = Attribute.new(name, &block)
+      end
+
+      def attributes(*names)
+        names.each { |name| attribute(name) }
+      end
+
+      def belongs_to(name, options={}, &block)
+        @links[name] = Relationships::BelongsTo.new(name, options, &block)
+      end
+
+      def has_many(name, options={}, &block)
+        @links[name] = Relationships::HasMany.new(name, options, &block)
+      end
+
+      def links(generator, resource)
+        @links.each_value { |link| link.generate(generator, resource) }
+      end
+
+      def resource(generator, resource)
+        @attrs.each_value { |attr| attr.generate(generator, resource) }
+      end
+    end
+  end
+end

data/lib/ivy/serializers/railtie.rb

@@ -0,0 +1,13 @@
+require 'ivy/serializers/action_controller/serialization_support'
+
+module Ivy
+  module Serializers
+    class Railtie < ::Rails::Railtie
+      initializer 'ivy.serializers.controllers' do
+        ActiveSupport.on_load(:action_controller) do
+          include ::Ivy::Serializers::ActionController::SerializationSupport
+        end
+      end
+    end
+  end
+end

data/lib/ivy/serializers/registry.rb

@@ -0,0 +1,33 @@
+require 'ivy/serializers/mapping'
+
+module Ivy
+  module Serializers
+    class Registry
+      def initialize
+        @mappings = Hash.new { |hash, klass| hash[klass] = new_mapping(klass) }
+      end
+
+      def links(generator, resource)
+        mapping_for(resource.class).links(generator, resource)
+      end
+
+      def map(klass, &block)
+        mapping_for(klass).instance_eval(&block)
+      end
+
+      def resource(generator, resource)
+        mapping_for(resource.class).resource(generator, resource)
+      end
+
+      private
+
+      def mapping_for(klass)
+        @mappings[klass]
+      end
+
+      def new_mapping(klass)
+        Mapping.new(klass)
+      end
+    end
+  end
+end

data/lib/ivy/serializers/relationships.rb

@@ -0,0 +1,2 @@
+require 'ivy/serializers/relationships/belongs_to'
+require 'ivy/serializers/relationships/has_many'

data/lib/ivy/serializers/relationships/belongs_to.rb

@@ -0,0 +1,13 @@
+require 'ivy/serializers/relationships/relationship'
+
+module Ivy
+  module Serializers
+    module Relationships
+      class BelongsTo < Relationship
+        def generate(generator, resource)
+          generator.belongs_to(@name, get(resource), @options)
+        end
+      end
+    end
+  end
+end

data/lib/ivy/serializers/relationships/has_many.rb

@@ -0,0 +1,13 @@
+require 'ivy/serializers/relationships/relationship'
+
+module Ivy
+  module Serializers
+    module Relationships
+      class HasMany < Relationship
+        def generate(generator, resource)
+          generator.has_many(@name, get(resource), @options)
+        end
+      end
+    end
+  end
+end

data/lib/ivy/serializers/relationships/relationship.rb

@@ -0,0 +1,23 @@
+module Ivy
+  module Serializers
+    module Relationships
+      class Relationship
+        def initialize(name, options={}, &getter)
+          @name = name
+          @options = options
+          @getter = getter || method(:default_getter)
+        end
+
+        private
+
+        def default_getter(resource)
+          resource.public_send(@name)
+        end
+
+        def get(resource)
+          @getter.call(resource)
+        end
+      end
+    end
+  end
+end

data/lib/ivy/serializers/serializer.rb

@@ -0,0 +1,35 @@
+require 'ivy/serializers/registry'
+
+module Ivy
+  module Serializers
+    class Serializer
+      class << self
+        attr_accessor :_registry
+
+        def inherited(base)
+          base._registry = Registry.new
+        end
+
+        def links(generator, resource)
+          _registry.links(generator, resource)
+        end
+
+        def map(klass, &block)
+          _registry.map(klass, &block)
+        end
+
+        def resource(generator, resource)
+          _registry.resource(generator, resource)
+        end
+      end
+
+      def links(generator, links)
+        self.class.links(generator, links)
+      end
+
+      def resource(generator, resource)
+        self.class.resource(generator, resource)
+      end
+    end
+  end
+end

data/lib/ivy/serializers/version.rb

@@ -0,0 +1,5 @@
+module Ivy
+  module Serializers
+    VERSION = '0.1.0'
+  end
+end

data/spec/integration/formats/active_model_serializers_spec.rb

@@ -0,0 +1,143 @@
+require 'ivy/serializers'
+
+RSpec.describe Ivy::Serializers::Formats::ActiveModelSerializers do
+  let(:format) { described_class.new(document) }
+
+  describe '#as_json' do
+    let(:registry) { Ivy::Serializers::Registry.new }
+    let(:document) { Ivy::Serializers::Documents.create(registry, :post, post) }
+
+    subject { format.as_json }
+
+    context 'with default mapping' do
+      let(:post) { double('post', :id => 1) }
+
+      it { should eq(:post => {:id => 1}) }
+    end
+
+    context 'with an attribute' do
+      let(:post_class) { double('Post') }
+      let(:post) { double('post', :class => post_class, :id => 1, :title => 'title') }
+
+      context 'with default options' do
+        before do
+          registry.map post_class do
+            attribute :title
+          end
+        end
+
+        it { should eq(:post => {:id => 1, :title => 'title'}) }
+      end
+
+      context 'with a block provided' do
+        before do
+          registry.map post_class do
+            attribute(:headline) { |post| post.title }
+          end
+        end
+
+        it { should eq(:post => {:id => 1, :headline => 'title'}) }
+      end
+    end
+
+    context 'with a belongs_to relationship' do
+      let(:author_class) { double('Author', :name => 'Author') }
+      let(:author) { double('author', :class => author_class, :id => 1) }
+      let(:post_class) { double('Post') }
+      let(:post) { double('post', :author => author, :class => post_class, :id => 1) }
+
+      context 'with default options' do
+        before do
+          registry.map post_class do
+            belongs_to :author
+          end
+        end
+
+        it { should eq(:post => {:author_id => 1, :id => 1}) }
+      end
+
+      context 'with a block provided' do
+        before do
+          registry.map post_class do
+            belongs_to(:user) { |post| post.author }
+          end
+        end
+
+        it { should eq(:post => {:id => 1, :user_id => 1}) }
+      end
+
+      context 'with the :embed_in_root option' do
+        before do
+          registry.map post_class do
+            belongs_to :author, :embed_in_root => true
+          end
+        end
+
+        it { should eq(
+          :authors => [{:id => 1}],
+          :post => {:author_id => 1, :id => 1}
+        ) }
+      end
+
+      context 'with the :polymorphic option' do
+        before do
+          registry.map post_class do
+            belongs_to :author, :polymorphic => true
+          end
+        end
+
+        it { should eq(:post => {:author => {:id => 1, :type => 'author'}, :id => 1}) }
+      end
+    end
+
+    context 'with a has_many relationship' do
+      let(:comment_class) { double('Comment', :name => 'Comment') }
+      let(:comment) { double('comment', :class => comment_class, :id => 1) }
+      let(:post_class) { double('Post') }
+      let(:post) { double('post', :class => post_class, :comments => [comment], :id => 1) }
+
+      context 'with default options' do
+        before do
+          registry.map post_class do
+            has_many :comments
+          end
+        end
+
+        it { should eq(:post => {:comment_ids => [1], :id => 1}) }
+      end
+
+      context 'with a block provided' do
+        before do
+          registry.map post_class do
+            has_many(:replies) { |post| post.comments }
+          end
+        end
+
+        it { should eq(:post => {:id => 1, :reply_ids => [1]}) }
+      end
+
+      context 'with the :embed_in_root option' do
+        before do
+          registry.map post_class do
+            has_many :comments, :embed_in_root => true
+          end
+        end
+
+        it { should eq(
+          :comments => [{:id => 1}],
+          :post => {:comment_ids => [1], :id => 1}
+        ) }
+      end
+
+      context 'with the :polymorphic option' do
+        before do
+          registry.map post_class do
+            has_many :comments, :polymorphic => true
+          end
+        end
+
+        it { should eq(:post => {:comments => [{:id => 1, :type => 'comment'}], :id => 1}) }
+      end
+    end
+  end
+end