active_model_serializers 0.9.9 → 0.10.0.rc1

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.ruby_opts = ['-r./test/test_helper.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/active_model_serializers.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_model/serializer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_model_serializers"
+  spec.version       = ActiveModel::Serializer::VERSION
+  spec.authors       = ["Steve Klabnik"]
+  spec.email         = ["steve@steveklabnik.com"]
+  spec.summary       = %q{Conventions-based JSON generation for Rails.}
+  spec.description   = %q{ActiveModel::Serializers allows you to generate your JSON in an object-oriented and convention-driven manner.}
+  spec.homepage      = "https://github.com/rails-api/active_model_serializers"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activemodel", ">= 4.0"
+
+  spec.add_development_dependency "rails", ">= 4.0"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/action_controller/serialization.rb

@@ -1,106 +1,61 @@
 require 'active_support/core_ext/class/attribute'
 
 module ActionController
-  # Action Controller Serialization
-  #
-  # Overrides render :json to check if the given object implements +active_model_serializer+
-  # as a method. If so, use the returned serializer instead of calling +to_json+ on the object.
-  #
-  # This module also provides a serialization_scope method that allows you to configure the
-  # +serialization_scope+ of the serializer. Most apps will likely set the +serialization_scope+
-  # to the current user:
-  #
-  #    class ApplicationController < ActionController::Base
-  #      serialization_scope :current_user
-  #    end
-  #
-  # If you need more complex scope rules, you can simply override the serialization_scope:
-  #
-  #    class ApplicationController < ActionController::Base
-  #      private
-  #
-  #      def serialization_scope
-  #        current_user
-  #      end
-  #    end
-  #
   module Serialization
     extend ActiveSupport::Concern
 
     include ActionController::Renderers
 
-    class << self
-      attr_accessor :enabled
-    end
-    self.enabled = true
+    ADAPTER_OPTION_KEYS = [:include, :fields, :root, :adapter]
 
     included do
       class_attribute :_serialization_scope
       self._serialization_scope = :current_user
     end
 
-    module ClassMethods
-      def serialization_scope(scope)
-        self._serialization_scope = scope
-      end
-    end
-
-    [:_render_option_json, :_render_with_renderer_json].each do |renderer_method|
-      define_method renderer_method do |resource, options|
-        serializer = build_json_serializer(resource, options)
-
-        if serializer
-          super(serializer, options)
-        else
-          super(resource, options)
-        end
-      end
-    end
-
-    private
-
-    def namespace_for_serializer
-      @namespace_for_serializer ||= namespace_for_class(self.class) unless namespace_for_class(self.class) == Object
+    def serialization_scope
+      send(_serialization_scope) if _serialization_scope &&
+        respond_to?(_serialization_scope, true)
     end
 
-    def namespace_for_class(klass)
-      if Module.method_defined?(:module_parent)
-        klass.module_parent
-      else
-        klass.parent
-      end
-    end
+    def get_serializer(resource)
+      @_serializer ||= @_serializer_opts.delete(:serializer)
+      @_serializer ||= ActiveModel::Serializer.serializer_for(resource)
 
-    def default_serializer(resource)
-      options = {}.tap do |o|
-        o[:namespace] = namespace_for_serializer if namespace_for_serializer
+      if @_serializer_opts.key?(:each_serializer)
+        @_serializer_opts[:serializer] = @_serializer_opts.delete(:each_serializer)
       end
 
-      ActiveModel::Serializer.serializer_for(resource, options)
+      @_serializer
     end
 
-    def default_serializer_options
-      {}
+    def use_adapter?
+      !(@_adapter_opts.key?(:adapter) && !@_adapter_opts[:adapter])
     end
 
-    def serialization_scope
-      _serialization_scope = self.class._serialization_scope
-      send(_serialization_scope) if _serialization_scope && respond_to?(_serialization_scope, true)
-    end
+    [:_render_option_json, :_render_with_renderer_json].each do |renderer_method|
+      define_method renderer_method do |resource, options|
+        @_adapter_opts, @_serializer_opts =
+          options.partition { |k, _| ADAPTER_OPTION_KEYS.include? k }.map { |h| Hash[h] }
 
-    def build_json_serializer(resource, options = {})
-      options = default_serializer_options.merge(options)
-      @namespace_for_serializer = options.fetch(:namespace, nil)
+        if use_adapter? && (serializer = get_serializer(resource))
 
-      if serializer = options.fetch(:serializer, default_serializer(resource))
-        options[:scope] = serialization_scope unless options.has_key?(:scope)
+          @_serializer_opts[:scope] ||= serialization_scope
+          @_serializer_opts[:scope_name] = _serialization_scope
 
-        if resource.respond_to?(:to_ary)
-          options[:resource_name] = controller_name 
-          options[:namespace] = namespace_for_serializer if namespace_for_serializer
+          # omg hax
+          object = serializer.new(resource, @_serializer_opts)
+          adapter = ActiveModel::Serializer::Adapter.create(object, @_adapter_opts)
+          super(adapter, options)
+        else
+          super(resource, options)
         end
+      end
+    end
 
-        serializer.new(resource, options)
+    module ClassMethods
+      def serialization_scope(scope)
+        self._serialization_scope = scope
       end
     end
   end

data/lib/active_model/serializer/adapter/fragment_cache.rb

@@ -0,0 +1,78 @@
+module ActiveModel
+  class Serializer
+    class Adapter
+      class FragmentCache
+
+        attr_reader :serializer
+
+        def initialize(adapter, serializer, options, root)
+          @root       = root
+          @options    = options
+          @adapter    = adapter
+          @serializer = serializer
+        end
+
+        def fetch
+          klass = serializer.class
+          # It will split the serializer into two, one that will be cached and other wont
+          serializers = fragment_serializer(serializer.object.class.name, klass)
+
+          # Instanciate both serializers
+          cached_serializer     = serializers[:cached].constantize.new(serializer.object)
+          non_cached_serializer = serializers[:non_cached].constantize.new(serializer.object)
+
+          cached_adapter     = @adapter.class.new(cached_serializer, @options)
+          non_cached_adapter = @adapter.class.new(non_cached_serializer, @options)
+
+          # Get serializable hash from both
+          cached_hash     = cached_adapter.serializable_hash
+          non_cached_hash = non_cached_adapter.serializable_hash
+
+          # Merge both results
+          @adapter.fragment_cache(cached_hash, non_cached_hash)
+        end
+
+        private
+
+        def cached_attributes(klass, serializers)
+          cached_attributes     = (klass._cache_only) ? klass._cache_only : serializer.attributes.keys.delete_if {|attr| klass._cache_except.include?(attr) }
+          non_cached_attributes = serializer.attributes.keys.delete_if {|attr| cached_attributes.include?(attr) }
+
+          cached_attributes.each do |attribute|
+            options = serializer.class._attributes_keys[attribute]
+            options ||= {}
+            # Add cached attributes to cached Serializer
+            serializers[:cached].constantize.attribute(attribute, options)
+          end
+
+          non_cached_attributes.each do |attribute|
+            options = serializer.class._attributes_keys[attribute]
+            options ||= {}
+            # Add non-cached attributes to non-cached Serializer
+            serializers[:non_cached].constantize.attribute(attribute, options)
+          end
+        end
+
+        def fragment_serializer(name, klass)
+          cached     = "#{name.capitalize}CachedSerializer"
+          non_cached = "#{name.capitalize}NonCachedSerializer"
+
+          Object.const_set cached, Class.new(ActiveModel::Serializer) unless Object.const_defined?(cached)
+          Object.const_set non_cached, Class.new(ActiveModel::Serializer) unless Object.const_defined?(non_cached)
+
+          klass._cache_options       ||= {}
+          klass._cache_options[:key] = klass._cache_key if klass._cache_key
+
+          cached.constantize.cache(klass._cache_options)
+
+          cached.constantize.fragmented(serializer)
+          non_cached.constantize.fragmented(serializer)
+
+          serializers = {cached: cached, non_cached: non_cached}
+          cached_attributes(klass, serializers)
+          serializers
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/json/fragment_cache.rb

@@ -0,0 +1,15 @@
+module ActiveModel
+  class Serializer
+    class Adapter
+      class Json < Adapter
+        class FragmentCache
+
+          def fragment_cache(cached_hash, non_cached_hash)
+            non_cached_hash.merge cached_hash
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/json.rb

@@ -0,0 +1,52 @@
+require 'active_model/serializer/adapter/json/fragment_cache'
+
+module ActiveModel
+  class Serializer
+    class Adapter
+      class Json < Adapter
+        def serializable_hash(options = {})
+          if serializer.respond_to?(:each)
+            @result = serializer.map{|s| self.class.new(s).serializable_hash }
+          else
+            @hash = {}
+
+            @core = cache_check(serializer) do
+              serializer.attributes(options)
+            end
+
+            serializer.each_association do |name, association, opts|
+              if association.respond_to?(:each)
+                array_serializer = association
+                @hash[name] = array_serializer.map do |item|
+                  cache_check(item) do
+                    item.attributes(opts)
+                  end
+                end
+              else
+                if association
+                  @hash[name] = cache_check(association) do
+                    association.attributes(options)
+                  end
+                elsif opts[:virtual_value]
+                  @hash[name] = opts[:virtual_value]
+                else
+                  @hash[name] = nil
+                end
+              end
+            end
+            @result = @core.merge @hash
+          end
+
+          if root = options.fetch(:root, serializer.json_key)
+            @result = { root => @result }
+          end
+          @result
+        end
+      end
+
+      def fragment_cache(cached_hash, non_cached_hash)
+        Json::FragmentCache.new().fragment_cache(cached_hash, non_cached_hash)
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/json_api/fragment_cache.rb

@@ -0,0 +1,22 @@
+module ActiveModel
+  class Serializer
+    class Adapter
+      class JsonApi < Adapter
+        class FragmentCache
+
+          def fragment_cache(root, cached_hash, non_cached_hash)
+            hash              = {}
+            core_cached       = cached_hash.first
+            core_non_cached   = non_cached_hash.first
+            no_root_cache     = cached_hash.delete_if {|key, value| key == core_cached[0] }
+            no_root_non_cache = non_cached_hash.delete_if {|key, value| key == core_non_cached[0] }
+            cached_resource   = (core_cached[1]) ? core_cached[1].merge(core_non_cached[1]) : core_non_cached[1]
+            hash = (root) ? { root => cached_resource } : cached_resource
+            hash.merge no_root_non_cache.merge no_root_cache
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/json_api.rb

@@ -0,0 +1,152 @@
+require 'active_model/serializer/adapter/json_api/fragment_cache'
+
+module ActiveModel
+  class Serializer
+    class Adapter
+      class JsonApi < Adapter
+        def initialize(serializer, options = {})
+          super
+          serializer.root = true
+          @hash = { data: [] }
+
+          if fields = options.delete(:fields)
+            @fieldset = ActiveModel::Serializer::Fieldset.new(fields, serializer.json_key)
+          else
+            @fieldset = options[:fieldset]
+          end
+        end
+
+        def serializable_hash(options = {})
+          if serializer.respond_to?(:each)
+            serializer.each do |s|
+              result = self.class.new(s, @options.merge(fieldset: @fieldset)).serializable_hash
+              @hash[:data] << result[:data]
+
+              if result[:included]
+                @hash[:included] ||= []
+                @hash[:included] |= result[:included]
+              end
+            end
+          else
+            @hash[:data] = attributes_for_serializer(serializer, @options)
+            add_resource_links(@hash[:data], serializer)
+          end
+          @hash
+        end
+
+        def fragment_cache(cached_hash, non_cached_hash)
+          root = false if @options.include?(:include)
+          JsonApi::FragmentCache.new().fragment_cache(root, cached_hash, non_cached_hash)
+        end
+
+        private
+
+        def add_links(resource, name, serializers)
+          resource[:links] ||= {}
+          resource[:links][name] ||= { linkage: [] }
+          resource[:links][name][:linkage] += serializers.map { |serializer| { type: serializer.type, id: serializer.id.to_s } }
+        end
+
+        def add_link(resource, name, serializer, val=nil)
+          resource[:links] ||= {}
+          resource[:links][name] = { linkage: nil }
+
+          if serializer && serializer.object
+            resource[:links][name][:linkage] = { type: serializer.type, id: serializer.id.to_s }
+          end
+        end
+
+        def add_included(resource_name, serializers, parent = nil)
+          unless serializers.respond_to?(:each)
+            return unless serializers.object
+            serializers = Array(serializers)
+          end
+          resource_path = [parent, resource_name].compact.join('.')
+          if include_assoc?(resource_path)
+            @hash[:included] ||= []
+
+            serializers.each do |serializer|
+              attrs = attributes_for_serializer(serializer, @options)
+
+              add_resource_links(attrs, serializer, add_included: false)
+
+              @hash[:included].push(attrs) unless @hash[:included].include?(attrs)
+            end
+          end
+
+          serializers.each do |serializer|
+            serializer.each_association do |name, association, opts|
+              add_included(name, association, resource_path) if association
+            end if include_nested_assoc? resource_path
+          end
+        end
+
+        def attributes_for_serializer(serializer, options)
+          if serializer.respond_to?(:each)
+            result = []
+            serializer.each do |object|
+              options[:fields] = @fieldset && @fieldset.fields_for(serializer)
+              result << cache_check(object) do
+                options[:required_fields] = [:id, :type]
+                attributes = object.attributes(options)
+                attributes[:id] = attributes[:id].to_s
+                result << attributes
+              end
+            end
+          else
+            options[:fields] = @fieldset && @fieldset.fields_for(serializer)
+            options[:required_fields] = [:id, :type]
+            result = cache_check(serializer) do
+              result = serializer.attributes(options)
+              result[:id] = result[:id].to_s
+              result
+            end
+          end
+          result
+        end
+
+        def include_assoc?(assoc)
+          return false unless @options[:include]
+          check_assoc("#{assoc}$")
+        end
+
+        def include_nested_assoc?(assoc)
+          return false unless @options[:include]
+          check_assoc("#{assoc}.")
+        end
+
+        def check_assoc(assoc)
+          include_opt = @options[:include]
+          include_opt = include_opt.split(',') if include_opt.is_a?(String)
+          include_opt.any? do |s|
+            s.match(/^#{assoc.gsub('.', '\.')}/)
+          end
+        end
+
+        def add_resource_links(attrs, serializer, options = {})
+          options[:add_included] = options.fetch(:add_included, true)
+
+          serializer.each_association do |name, association, opts|
+            attrs[:links] ||= {}
+
+            if association.respond_to?(:each)
+              add_links(attrs, name, association)
+            else
+              if opts[:virtual_value]
+                add_link(attrs, name, nil, opts[:virtual_value])
+              else
+                add_link(attrs, name, association)
+              end
+            end
+
+            if options[:add_included]
+              Array(association).each do |association|
+                add_included(name, association)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/null.rb

@@ -0,0 +1,11 @@
+module ActiveModel
+  class Serializer
+    class Adapter
+      class Null < Adapter
+        def serializable_hash(options = {})
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter.rb

@@ -0,0 +1,87 @@
+require 'active_model/serializer/adapter/fragment_cache'
+
+module ActiveModel
+  class Serializer
+    class Adapter
+      extend ActiveSupport::Autoload
+      autoload :Json
+      autoload :Null
+      autoload :JsonApi
+
+      attr_reader :serializer
+
+      def initialize(serializer, options = {})
+        @serializer = serializer
+        @options = options
+      end
+
+      def serializable_hash(options = {})
+        raise NotImplementedError, 'This is an abstract method. Should be implemented at the concrete adapter.'
+      end
+
+      def as_json(options = {})
+        hash = serializable_hash(options)
+        include_meta(hash)
+      end
+
+      def self.create(resource, options = {})
+        override = options.delete(:adapter)
+        klass = override ? adapter_class(override) : ActiveModel::Serializer.adapter
+        klass.new(resource, options)
+      end
+
+      def self.adapter_class(adapter)
+        "ActiveModel::Serializer::Adapter::#{adapter.to_s.classify}".safe_constantize
+      end
+
+      def fragment_cache(*args)
+        raise NotImplementedError, 'This is an abstract method. Should be implemented at the concrete adapter.'
+      end
+
+      private
+
+     def cache_check(serializer)
+        @cached_serializer = serializer
+        @klass             = @cached_serializer.class
+        if is_cached?
+          @klass._cache.fetch(cache_key, @klass._cache_options) do
+            yield
+          end
+        elsif is_fragment_cached?
+          FragmentCache.new(self, @cached_serializer, @options, @root).fetch
+        else
+          yield
+        end
+      end
+
+      def is_cached?
+        @klass._cache && !@klass._cache_only && !@klass._cache_except
+      end
+
+      def is_fragment_cached?
+        @klass._cache_only && !@klass._cache_except || !@klass._cache_only && @klass._cache_except
+      end
+
+      def cache_key
+        (@klass._cache_key) ? "#{@klass._cache_key}/#{@cached_serializer.object.id}-#{@cached_serializer.object.updated_at}" : @cached_serializer.object.cache_key
+      end
+
+      def meta
+        serializer.meta if serializer.respond_to?(:meta)
+      end
+
+      def meta_key
+        serializer.meta_key || "meta"
+      end
+
+      def root
+        serializer.json_key
+      end
+
+      def include_meta(json)
+        json[meta_key] = meta if meta && root
+        json
+      end
+    end
+  end
+end

data/lib/active_model/serializer/array_serializer.rb

@@ -0,0 +1,32 @@
+module ActiveModel
+  class Serializer
+    class ArraySerializer
+      include Enumerable
+      delegate :each, to: :@objects
+
+      attr_reader :meta, :meta_key
+
+      def initialize(objects, options = {})
+        options.merge!(root: nil)
+
+        @objects = objects.map do |object|
+          serializer_class = options.fetch(
+            :serializer,
+            ActiveModel::Serializer.serializer_for(object)
+          )
+          serializer_class.new(object, options)
+        end
+        @meta     = options[:meta]
+        @meta_key = options[:meta_key]
+      end
+
+      def json_key
+        @objects.first.json_key if @objects.first
+      end
+
+      def root=(root)
+        @objects.first.root = root if @objects.first
+      end
+    end
+  end
+end

data/lib/active_model/serializer/configuration.rb

@@ -0,0 +1,13 @@
+module ActiveModel
+  class Serializer
+    module Configuration
+      include ActiveSupport::Configurable
+      extend ActiveSupport::Concern
+
+      included do |base|
+        base.config.array_serializer = ActiveModel::Serializer::ArraySerializer
+        base.config.adapter = :json
+      end
+    end
+  end
+end

data/lib/active_model/serializer/fieldset.rb

@@ -0,0 +1,40 @@
+module ActiveModel
+  class Serializer
+    class Fieldset
+
+      def initialize(fields, root = nil)
+        @root       = root
+        @raw_fields = fields
+      end
+
+      def fields
+        @fields ||= parsed_fields
+      end
+
+      def fields_for(serializer)
+        key = serializer.json_key || serializer.class.root_name
+        fields[key.to_sym]
+      end
+
+    private
+
+      attr_reader :raw_fields, :root
+
+      def parsed_fields
+        if raw_fields.is_a?(Hash)
+          raw_fields.inject({}) { |h,(k,v)| h[k.to_sym] = v.map(&:to_sym); h}
+        elsif raw_fields.is_a?(Array)
+          if root.nil?
+            raise ArgumentError, 'The root argument must be specified if the fileds argument is an array.'
+          end
+          hash = {}
+          hash[root.to_sym] = raw_fields.map(&:to_sym)
+          hash
+        else
+          {}
+        end
+      end
+
+    end
+  end
+end