encore 0.0.3 → 0.1

data/lib/encore/persister/links_parser.rb

@@ -0,0 +1,57 @@
+module Encore
+  module Persister
+    module LinksParser
+      extend ActiveSupport::Concern
+
+      def parse_links(args)
+        links = args.delete(:links) || []
+
+        links.each do |link, value|
+          reflection = @model.reflections[link.to_sym]
+          key = fetch_key(reflection)
+          value = fetch_value(value, reflection)
+
+          args.merge!(key => value) if key
+        end
+
+        args
+      end
+
+    private
+
+      # `belongs_to` => 'user' become 'user_id'
+      def link_belongs_to(reflection)
+        reflection.foreign_key.to_sym
+      end
+
+      # `has_many` => 'users' become 'user_ids'
+      def link_has_many(reflection)
+        "#{reflection.name.to_s.singularize}_ids".to_sym
+      end
+
+      # `has_one` => 'user' stay 'user'
+      def link_has_one(reflection)
+        reflection.name
+      end
+
+      # Convert reflection with the right ActiveRecord key for insert/update.
+      def fetch_key(reflection)
+        case reflection.macro
+          when :belongs_to then link_belongs_to(reflection)
+          when :has_many then link_has_many(reflection)
+          when :has_one then link_has_one(reflection)
+        end
+      end
+
+      # Value for `has_one` must be an activerecord instance.
+      # Other reflection macro types stay the same.
+      def fetch_value(value, reflection)
+        if reflection.macro == :has_one
+          reflection.klass.find(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/encore/persister/param_injection.rb

@@ -0,0 +1,15 @@
+module Encore
+  module Persister
+    module ParamInjection
+      def self.inject(payload, injection)
+        return payload if injection.nil?
+
+        payload.map do |param|
+          injection.reduce(param) do |memo, (key, value)|
+            memo.merge key => value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/encore/serializer/base.rb

@@ -0,0 +1,48 @@
+require 'encore/serializer/links_reflection_includer'
+
+module Encore
+  module Serializer
+    class Base < ::ActiveModel::Serializer
+      def id
+        object.id.to_s
+      end
+
+      def links
+        object.reflections.each_with_object({}) do |(_, reflection), memo|
+          if object.association(reflection.name).loaded?
+            fetcher = LinksReflectionIncluder::Loaded
+          else
+            next unless self.class.can_access.include?(reflection.name)
+            fetcher = LinksReflectionIncluder::NotLoaded
+          end
+
+          memo.merge!(reflection.name => fetcher.send("reflection_#{reflection.macro}", object, reflection))
+        end
+      end
+
+      # Specify which resources the API can be included in the "linked" top-level key.
+      def self.can_include
+        []
+      end
+
+      # Specify which resources the API always include in the "linked" top-level key.
+      def self.always_include
+        []
+      end
+
+      # Specify which resources the API exposes URL to.
+      # Default is can_include + always_include.
+      def self.can_access
+        can_include | always_include
+      end
+
+      def self.root_key
+        model_class.name.pluralize.underscore.to_sym
+      end
+
+      def self.key_mappings
+        {}
+      end
+    end
+  end
+end

data/lib/encore/serializer/eager_loading_manager.rb

@@ -0,0 +1,11 @@
+module Encore
+  module Serializer
+    module EagerLoadingManager
+      extend ActiveSupport::Concern
+
+      def self.add(collection, option_include)
+        collection.includes(option_include)
+      end
+    end
+  end
+end

data/lib/encore/serializer/instance.rb

@@ -0,0 +1,56 @@
+require 'encore/serializer/eager_loading_manager'
+require 'encore/serializer/linked_resource_manager'
+require 'encore/serializer/main_resource_manager'
+require 'encore/serializer/main_resource_links_manager'
+require 'encore/serializer/meta_manager'
+require 'encore/serializer/utils'
+require 'encore/serializer/options_parser'
+
+module Encore
+  module Serializer
+    class Instance
+      def initialize(collection, opts = {})
+        @collection = collection
+        @serializers = [serializer]
+        @options = parsed_options(opts)
+      end
+
+      def as_json(*_)
+        # Prepare main collection
+        @collection = MetaManager.paginate_collection(@collection, @options)
+        @collection = EagerLoadingManager.add(@collection, @options[:include])
+
+        # Fetch linked ids
+        linked_ids = MainResourceLinksManager.add(@collection, reflections, @options[:include])
+
+        # Build final output
+        output = MainResourceManager.add(@collection, serializer)
+        output.merge! linked: LinkedResourceManager.add(linked_ids)
+        output.merge! meta: MetaManager.add(@collection, serializer, @options)
+
+        output
+      end
+
+    private
+
+      def reflections
+        @reflections ||= @collection.klass.reflections
+      end
+
+      def serializer
+        @serializer ||= Utils.fetch_serializer(@collection.klass)
+      end
+
+      def parsed_options(opts)
+        parser = OptionsParser.new(opts)
+
+        {
+          include: parser.include(serializer),
+          skip_paging: parser.skip_paging,
+          page: parser.page,
+          per_page: parser.per_page
+        }
+      end
+    end
+  end
+end

data/lib/encore/serializer/linked_resource_manager.rb

@@ -0,0 +1,19 @@
+require 'encore/serializer/utils'
+
+module Encore
+  module Serializer
+    module LinkedResourceManager
+      extend ActiveSupport::Concern
+
+      def self.add(linked_ids)
+        linked_ids.reduce({}) do |memo, (model, ids)|
+          klass = model.constantize
+          serializer = Utils.fetch_serializer(klass)
+
+          collection = klass.where(id: ids.to_a)
+          memo.merge! MainResourceManager.add(collection, serializer)
+        end
+      end
+    end
+  end
+end

data/lib/encore/serializer/links_reflection_includer.rb

@@ -0,0 +1,50 @@
+module Encore
+  module Serializer
+    module LinksReflectionIncluder
+      module Loaded
+        def self.reflection_belongs_to(object, reflection)
+          object.send(reflection.foreign_key).try(:to_s) if object.respond_to?(reflection.foreign_key)
+        end
+
+        def self.reflection_has_one(object, reflection)
+          object.send(reflection.name).try(:id).try(:to_s)
+        end
+
+        def self.reflection_has_many(object, reflection)
+          object.send("#{reflection.name.to_s.singularize}_ids").map(&:to_s) if object.send(reflection.name).loaded?
+        end
+      end
+
+      module NotLoaded
+        def self.reflection_has_many(object, reflection)
+          reflection_type = reflection.name.to_s.pluralize
+
+          {
+            href: "/#{reflection_type}?#{object.class.name.downcase}_id=#{object.id}",
+            type: reflection_type
+          }
+        end
+
+        def self.reflection_has_one(object, reflection)
+          reflection_type = reflection.name.to_s
+
+          {
+            href: "/#{object.class.name.downcase.pluralize}/#{object.id}/#{reflection_type}",
+            type: reflection_type.pluralize
+          }
+        end
+
+        def self.reflection_belongs_to(object, reflection)
+          reflection_type = reflection.name.to_s.pluralize
+          reflection_id = object.send(reflection.foreign_key).try(:to_s)
+
+          {
+            href: "/#{reflection_type}/#{reflection_id}",
+            id: reflection_id,
+            type: reflection_type
+          }
+        end
+      end
+    end
+  end
+end

data/lib/encore/serializer/main_resource_links_manager/reflection_belongs_to.rb

@@ -0,0 +1,13 @@
+module Encore
+  module Serializer
+    module MainResourceLinksManager
+      module ReflectionBelongsTo
+        extend ActiveSupport::Concern
+
+        def self.add(item, reflection)
+          [item.send(reflection.foreign_key).try(:to_s)]
+        end
+      end
+    end
+  end
+end

data/lib/encore/serializer/main_resource_links_manager/reflection_has_many.rb

@@ -0,0 +1,13 @@
+module Encore
+  module Serializer
+    module MainResourceLinksManager
+      module ReflectionHasMany
+        extend ActiveSupport::Concern
+
+        def self.add(item, reflection)
+          item.send("#{reflection.name.to_s.singularize}_ids").map(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/encore/serializer/main_resource_links_manager/reflection_has_one.rb

@@ -0,0 +1,13 @@
+module Encore
+  module Serializer
+    module MainResourceLinksManager
+      module ReflectionHasOne
+        extend ActiveSupport::Concern
+
+        def self.add(item, reflection)
+          [item.send(reflection.name).try(:id).try(:to_s)]
+        end
+      end
+    end
+  end
+end

data/lib/encore/serializer/main_resource_links_manager.rb

@@ -0,0 +1,45 @@
+require 'encore/serializer/main_resource_links_manager/reflection_belongs_to'
+require 'encore/serializer/main_resource_links_manager/reflection_has_many'
+require 'encore/serializer/main_resource_links_manager/reflection_has_one'
+
+module Encore
+  module Serializer
+    module MainResourceLinksManager
+      extend ActiveSupport::Concern
+
+      def self.add(collection, reflections, option_include)
+        collection.each_with_object(Hash.new(Set.new)) do |resource, memo|
+          option_include.each do |inclusion|
+            model, ids = association_collection(resource, inclusion, reflections)
+            memo[model] += ids
+          end
+        end
+      end
+
+    private
+
+      def self.association_collection(item, inclusion, reflections)
+        reflection = reflections[inclusion]
+        class_name = fetch_class_name(item, reflection)
+
+        collection = begin
+          case reflection.macro
+            when :belongs_to then ReflectionBelongsTo.add(item, reflection)
+            when :has_one then ReflectionHasOne.add(item, reflection)
+            when :has_many then ReflectionHasMany.add(item, reflection)
+          end
+        end
+
+        [class_name, collection.flatten.compact]
+      end
+
+      def self.fetch_class_name(item, reflection)
+        if reflection.options[:polymorphic]
+          item.send(reflection.foreign_type).constantize.to_s
+        else
+          reflection.klass.name.to_s
+        end
+      end
+    end
+  end
+end

data/lib/encore/serializer/main_resource_manager.rb

@@ -0,0 +1,13 @@
+module Encore
+  module Serializer
+    module MainResourceManager
+      extend ActiveSupport::Concern
+
+      def self.add(collection, serializer)
+        {
+          serializer.root_key => collection.map { |o| serializer.new(o).as_json }
+        }
+      end
+    end
+  end
+end

data/lib/encore/serializer/meta_manager.rb

@@ -0,0 +1,29 @@
+module Encore
+  module Serializer
+    module MetaManager
+      extend ActiveSupport::Concern
+
+      def self.paginate_collection(collection, options)
+        return collection if options[:skip_paging]
+
+        collection.page(options[:page]).per(options[:per_page])
+      end
+
+      def self.add(collection, serializer, options)
+        return {} if options[:skip_paging]
+
+        { serializer.root_key => pagination_for(collection) }
+      end
+
+      def self.pagination_for(collection)
+        {
+          page: collection.current_page,
+          count: collection.total_count,
+          page_count: collection.num_pages,
+          previous_page: collection.prev_page,
+          next_page: collection.next_page
+        }
+      end
+    end
+  end
+end

data/lib/encore/serializer/options_parser.rb

@@ -0,0 +1,51 @@
+module Encore
+  module Serializer
+    class OptionsParser
+      def initialize(opts)
+        @opts = opts
+      end
+
+      def include(serializer)
+        opt = @opts[:include]
+
+        output = []
+
+        # Split includes list
+        output += opt.split(',').map(&:to_sym) if opt.present?
+
+        # Remove resource type not included in 'can_include'
+        output = serializer.can_include & output if serializer.respond_to?(:can_include)
+
+        # Add 'always_include' resource type
+        output += serializer.always_include if serializer.respond_to?(:always_include)
+
+        output
+      end
+
+      def page
+        opt = @opts[:page]
+
+        opt.present? ? opt.to_i : 1
+      end
+
+      def per_page
+        opt = @opts[:per_page]
+
+        return Kaminari.config.default_per_page if opt.nil?
+
+        max_per_page = Kaminari.config.max_per_page.to_i
+        opt = opt.to_i
+
+        if max_per_page.zero?
+          opt
+        else
+          opt > max_per_page ? max_per_page : opt
+        end
+      end
+
+      def skip_paging
+        @opts[:skip_paging].present?
+      end
+    end
+  end
+end

data/lib/encore/serializer/utils.rb

@@ -0,0 +1,12 @@
+module Encore
+  module Serializer
+    module Utils
+      def self.fetch_serializer(model)
+        default_serializer = (model.name.gsub('::', '') + 'Serializer')
+        model.active_model_serializer || default_serializer.constantize
+      rescue NameError
+        raise NameError, "can’t find serializer for #{model.name}, try creating #{default_serializer}"
+      end
+    end
+  end
+end

data/lib/encore/version.rb

@@ -1,3 +1,3 @@
 module Encore
-  VERSION = '0.0.3'
+  VERSION = '0.1'
 end

data/lib/encore.rb

@@ -1,13 +1,21 @@
 require 'encore/version'
 
-# ActiveSupport
+require 'active_model_serializers'
+require 'active_record'
 require 'active_support'
 
-# Encore
-require 'encore/entity'
-require 'encore/attribute'
-require 'encore/association'
-require 'encore/helpers'
+# This is a dirty hack to fix dirty code
+# https://github.com/amatsuda/kaminari/blob/7b049067b143212a172d5bb472184eac23121f34/lib/kaminari.rb#L11-L25
+oldstderr = $stderr.dup
+$stderr = StringIO.new
+require 'kaminari'
+$stderr = oldstderr
 
-# Railtie
-require 'encore/railtie' if defined?(Rails) && Rails::VERSION::MAJOR >= 3
+require 'encore/config'
+
+require 'encore/serializer/base'
+require 'encore/serializer/instance'
+require 'encore/persister/instance'
+
+module Encore
+end

data/spec/encore/persister/belongs_to_links_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Encore::Persister do
+  let(:persister) { Encore::Persister::Instance }
+  let(:persist!) { persister.new(model, params).persist! }
+
+  before do
+    run_migrations!
+    spawn_models!
+  end
+
+  let(:run_migrations!) do
+    run_migration do
+      create_table(:users, force: true) do |t|
+        t.string :name, default: nil
+        t.integer :project_id, default: nil
+      end
+      create_table(:projects, force: true) do |t|
+        t.string :name, default: nil
+      end
+    end
+  end
+
+  let(:spawn_models!) do
+    spawn_model('User') do
+      belongs_to :project
+    end
+    spawn_model('Project')
+  end
+
+  let(:model) { User }
+  let(:project1) { Project.create name: 'a' }
+
+  let(:params) do
+    [{
+      name: 'Allan',
+      links: {
+        project: project1.id.to_s
+      }
+    }]
+  end
+
+  it { expect { persist! }.to change { model.count }.by(1) }
+  it { expect { persist! }.to change { model.first.try(:name) }.to('Allan') }
+  it { expect { persist! }.to change { model.first.try(:project) }.to(project1) }
+end

data/spec/encore/persister/create_resources_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Encore::Persister do
+  let(:persister) { Encore::Persister::Instance }
+  let(:persist!) { persister.new(model, params).persist! }
+
+  let(:run_migrations!) do
+    run_migration do
+      create_table(:users, force: true) do |t|
+        t.string :name, default: nil
+        t.string :phone, default: nil
+      end
+    end
+  end
+
+  let(:spawn_models!) do
+    spawn_model('User')
+  end
+
+  let(:model) { User }
+
+  before do
+    run_migrations!
+    spawn_models!
+  end
+
+  context 'single create' do
+    let(:params) do
+      [{
+        name: 'Allan',
+        phone: '555-2525'
+      }]
+    end
+
+    it { expect { persist! }.to change { model.count }.by(1) }
+    it { expect { persist! }.to change { model.first.try(:name) }.to('Allan') }
+    it { expect { persist! }.to change { model.first.try(:phone) }.to('555-2525') }
+  end
+
+  context 'many create' do
+    let(:params) do
+      [{
+        name: 'Allan',
+        phone: '555-2525'
+      }, {
+        name: 'Bob'
+      }]
+    end
+
+    it { expect { persist! }.to change { model.count }.by(2) }
+    it { expect { persist! }.to change { model.first.try(:name) }.to('Allan') }
+    it { expect { persist! }.to change { model.first.try(:phone) }.to('555-2525') }
+    it { expect { persist! }.to change { model.last.try(:name) }.to('Bob') }
+  end
+end

data/spec/encore/persister/errors_resources_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Encore::Persister do
+  let(:persister) { Encore::Persister::Instance.new(model, params) }
+  let(:persist!) { persister.persist! }
+
+  let(:run_migrations!) do
+    run_migration do
+      create_table(:users, force: true) do |t|
+        t.string :name, default: nil
+      end
+    end
+  end
+
+  let(:spawn_models!) do
+    spawn_model('User') do
+      validates :name, presence: true, length: { minimum: 2 }
+    end
+  end
+
+  before do
+    run_migrations!
+    spawn_models!
+  end
+
+  let(:params) do
+    [{
+      name: ''
+    }]
+  end
+
+  let(:expected_error) do
+    {
+      field: 'name',
+      types: ['can\'t be blank', 'is too short (minimum is 2 characters)'],
+      path: 'user/0/name'
+    }
+  end
+
+  context 'create' do
+    let(:model) { User }
+
+    it { expect { persist! }.to_not change { model.count } }
+    it { expect { persist! }.to change { persister.errors.count }.to(1) }
+    it { expect { persist! }.to change { persister.errors.first }.to(expected_error) }
+  end
+
+  context 'update' do
+    let(:model) { User.create name: 'Robert' }
+
+    it { expect { persist! }.to_not change { model.reload.name } }
+    it { expect { persist! }.to change { persister.errors.count }.to(1) }
+    it { expect { persist! }.to change { persister.errors.first }.to(expected_error) }
+  end
+end