active_model_serializers 0.9.8 → 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.rb

@@ -1,318 +1,258 @@
-require 'active_model/array_serializer'
-require 'active_model/serializable'
-require 'active_model/serializer/association'
-require 'active_model/serializer/config'
-
-require 'thread'
-require 'concurrent/map'
+require 'thread_safe'
 
 module ActiveModel
   class Serializer
-    include Serializable
-
-    @mutex = Mutex.new
+    extend ActiveSupport::Autoload
+    autoload :Configuration
+    autoload :ArraySerializer
+    autoload :Adapter
+    include Configuration
 
     class << self
-      def inherited(base)
-        base._root = _root
-        base._attributes = (_attributes || []).dup
-        base._associations = (_associations || {}).dup
-      end
+      attr_accessor :_attributes
+      attr_accessor :_attributes_keys
+      attr_accessor :_associations
+      attr_accessor :_urls
+      attr_accessor :_cache
+      attr_accessor :_fragmented
+      attr_accessor :_cache_key
+      attr_accessor :_cache_only
+      attr_accessor :_cache_except
+      attr_accessor :_cache_options
+    end
 
-      def setup
-        @mutex.synchronize do
-          yield CONFIG
-        end
-      end
+    def self.inherited(base)
+      base._attributes = []
+      base._attributes_keys = {}
+      base._associations = {}
+      base._urls = []
+    end
 
-      EMBED_IN_ROOT_OPTIONS = [
-        :include,
-        :embed_in_root,
-        :embed_in_root_key,
-        :embed_namespace
-      ].freeze
-
-      def embed(type, options={})
-        CONFIG.embed = type
-        if EMBED_IN_ROOT_OPTIONS.any? { |opt| options[opt].present? }
-          CONFIG.embed_in_root = true
-        end
-        if options[:embed_in_root_key].present?
-          CONFIG.embed_in_root_key = options[:embed_in_root_key]
-        end
-        ActiveSupport::Deprecation.warn <<-WARN
-** Notice: embed is deprecated. **
-The use of .embed method on a Serializer will be soon removed, as this should have a global scope and not a class scope.
-Please use the global .setup method instead:
-ActiveModel::Serializer.setup do |config|
-  config.embed = :#{type}
-  config.embed_in_root = #{CONFIG.embed_in_root || false}
-end
-        WARN
-      end
+    def self.attributes(*attrs)
+      attrs = attrs.first if attrs.first.class == Array
+      @_attributes.concat attrs
 
-      def format_keys(format)
-        @key_format = format
-      end
-      attr_reader :key_format
-
-      def serializer_for(resource, options = {})
-        if resource.respond_to?(:serializer_class)
-          resource.serializer_class
-        elsif resource.respond_to?(:to_ary)
-          if Object.constants.include?(:ArraySerializer)
-            ::ArraySerializer
-          else
-            ArraySerializer
-          end
-        else
-          klass_name = build_serializer_class(resource, options)
-          Serializer.serializers_cache.fetch_or_store(klass_name) do
-            _const_get(klass_name)
-          end
-        end
+      attrs.each do |attr|
+        define_method attr do
+          object && object.read_attribute_for_serialization(attr)
+        end unless method_defined?(attr) || _fragmented.respond_to?(attr)
       end
+    end
 
-      attr_accessor :_root, :_attributes, :_associations
-      alias root  _root=
-      alias root= _root=
+    def self.attribute(attr, options = {})
+      key = options.fetch(:key, attr)
+      @_attributes_keys[attr] = {key: key} if key != attr
+      @_attributes.concat [key]
+      define_method key do
+        object.read_attribute_for_serialization(attr)
+      end unless method_defined?(key) || _fragmented.respond_to?(attr)
+    end
 
-      def root_name
-        if name
-          root_name = name.demodulize.underscore.sub(/_serializer$/, '')
-          CONFIG.plural_default_root ? root_name.pluralize : root_name
-        end
-      end
+    def self.fragmented(serializer)
+      @_fragmented = serializer
+    end
 
-      def attributes(*attrs)
-        attrs.each do |attr|
-          striped_attr = strip_attribute attr
+    # Enables a serializer to be automatically cached
+    def self.cache(options = {})
+      @_cache         = ActionController::Base.cache_store if Rails.configuration.action_controller.perform_caching
+      @_cache_key     = options.delete(:key)
+      @_cache_only    = options.delete(:only)
+      @_cache_except  = options.delete(:except)
+      @_cache_options = (options.empty?) ? nil : options
+    end
+
+    # Defines an association in the object should be rendered.
+    #
+    # The serializer object should implement the association name
+    # as a method which should return an array when invoked. If a method
+    # with the association name does not exist, the association name is
+    # dispatched to the serialized object.
+    def self.has_many(*attrs)
+      associate(:has_many, attrs)
+    end
 
-          @_attributes << striped_attr
+    # Defines an association in the object that should be rendered.
+    #
+    # The serializer object should implement the association name
+    # as a method which should return an object when invoked. If a method
+    # with the association name does not exist, the association name is
+    # dispatched to the serialized object.
+    def self.belongs_to(*attrs)
+      associate(:belongs_to, attrs)
+    end
+
+    # Defines an association in the object should be rendered.
+    #
+    # The serializer object should implement the association name
+    # as a method which should return an object when invoked. If a method
+    # with the association name does not exist, the association name is
+    # dispatched to the serialized object.
+    def self.has_one(*attrs)
+      associate(:has_one, attrs)
+    end
 
-          define_method striped_attr do
-            object.read_attribute_for_serialization attr
-          end unless method_defined?(attr)
+    def self.associate(type, attrs) #:nodoc:
+      options = attrs.extract_options!
+      self._associations = _associations.dup
+
+      attrs.each do |attr|
+        unless method_defined?(attr)
+          define_method attr do
+            object.send attr
+          end
         end
-      end
 
-      def has_one(*attrs)
-        associate(Association::HasOne, *attrs)
+        self._associations[attr] = {type: type, association_options: options}
       end
+    end
+
+    def self.url(attr)
+      @_urls.push attr
+    end
+
+    def self.urls(*attrs)
+      @_urls.concat attrs
+    end
 
-      def has_many(*attrs)
-        associate(Association::HasMany, *attrs)
+    def self.serializer_for(resource, options = {})
+      if resource.respond_to?(:to_ary)
+        config.array_serializer
+      else
+        options
+          .fetch(:association_options, {})
+          .fetch(:serializer, get_serializer_for(resource.class))
       end
+    end
 
-      def serializers_cache
-        @serializers_cache ||= Concurrent::Map.new
+    def self.adapter
+      adapter_class = case config.adapter
+      when Symbol
+        ActiveModel::Serializer::Adapter.adapter_class(config.adapter)
+      when Class
+        config.adapter
+      end
+      unless adapter_class
+        valid_adapters = Adapter.constants.map { |klass| ":#{klass.to_s.downcase}" }
+        raise ArgumentError, "Unknown adapter: #{config.adapter}. Valid adapters are: #{valid_adapters}"
       end
 
-      private
+      adapter_class
+    end
 
-      def strip_attribute(attr)
-        symbolized = attr.is_a?(Symbol)
+    def self._root
+      @@root ||= false
+    end
 
-        attr = attr.to_s.gsub(/\?\Z/, '')
-        attr = attr.to_sym if symbolized
-        attr
-      end
+    def self._root=(root)
+      @@root = root
+    end
 
-      def build_serializer_class(resource, options)
-        "".tap do |klass_name|
-          klass_name << "#{options[:namespace]}::" if options[:namespace]
-          klass_name << options[:prefix].to_s.classify if options[:prefix]
-          klass_name << "#{resource.class.name}Serializer"
-        end
-      end
+    def self.root_name
+      name.demodulize.underscore.sub(/_serializer$/, '') if name
+    end
 
-      def associate(klass, *attrs)
-        options = attrs.extract_options!
+    attr_accessor :object, :root, :meta, :meta_key, :scope
 
-        attrs.each do |attr|
-          define_method attr do
-            object.send attr
-          end unless method_defined?(attr)
+    def initialize(object, options = {})
+      @object     = object
+      @options    = options
+      @root       = options[:root] || (self.class._root ? self.class.root_name : false)
+      @meta       = options[:meta]
+      @meta_key   = options[:meta_key]
+      @scope      = options[:scope]
 
-          @_associations[attr] = klass.new(attr, options)
+      scope_name = options[:scope_name]
+      if scope_name && !respond_to?(scope_name)
+        self.class.class_eval do
+          define_method scope_name, lambda { scope }
         end
       end
     end
 
-    def initialize(object, options={})
-      @object        = object
-      @scope         = options[:scope]
-      @root          = options.fetch(:root, self.class._root)
-      @polymorphic   = options.fetch(:polymorphic, false)
-      @meta_key      = options[:meta_key] || :meta
-      @meta          = options[@meta_key]
-      @wrap_in_array = options[:_wrap_in_array]
-      @only          = options[:only] ? Array(options[:only]) : nil
-      @except        = options[:except] ? Array(options[:except]) : nil
-      @key_format    = options[:key_format]
-      @context       = options[:context]
-      @namespace     = options[:namespace]
-    end
-    attr_accessor :object, :scope, :root, :meta_key, :meta, :key_format, :context, :polymorphic
-
     def json_key
-      key = if root == true || root.nil?
+      if root == true || root.nil?
         self.class.root_name
       else
         root
       end
-
-      key_format == :lower_camel && key.present? ? key.camelize(:lower) : key
     end
 
-    def attributes
-      filter(self.class._attributes.dup).each_with_object({}) do |name, hash|
-        hash[name] = send(name)
-      end
+    def id
+      object.id if object
     end
 
-    def associations(options={})
-      associations = self.class._associations
-      included_associations = filter(associations.keys)
-      associations.each_with_object({}) do |(name, association), hash|
-        if included_associations.include? name
-          if association.embed_ids?
-            ids = serialize_ids association
-            if association.embed_namespace?
-              hash = hash[association.embed_namespace] ||= {}
-              hash[association.key] = ids
-            else
-              hash[association.key] = ids
-            end
-          elsif association.embed_objects?
-            if association.embed_namespace?
-              hash = hash[association.embed_namespace] ||= {}
-            end
-            hash[association.embedded_key] = serialize association, options
-          end
-        end
-      end
+    def type
+      object.class.to_s.demodulize.underscore.pluralize
     end
 
-    def filter(keys)
-      if @only
-        keys & @only
-      elsif @except
-        keys - @except
-      else
-        keys
-      end
-    end
+    def attributes(options = {})
+      attributes =
+        if options[:fields]
+          self.class._attributes & options[:fields]
+        else
+          self.class._attributes.dup
+        end
 
-    def embedded_in_root_associations
-      associations = self.class._associations
-      included_associations = filter(associations.keys)
-      associations.each_with_object({}) do |(name, association), hash|
-        if included_associations.include? name
-          association_serializer = build_serializer(association)
-          # we must do this always because even if the current association is not
-          # embedded in root, it might have its own associations that are embedded in root
-          hash.merge!(association_serializer.embedded_in_root_associations) do |key, oldval, newval|
-            if oldval.respond_to?(:to_ary)
-              [oldval, newval].flatten.uniq
-            else
-              oldval.merge(newval) { |_, oldval, newval| [oldval, newval].flatten.uniq }
-            end
-          end
+      attributes += options[:required_fields] if options[:required_fields]
 
-          if association.embed_in_root?
-            if association.embed_in_root_key?
-              hash = hash[association.embed_in_root_key] ||= {}
-            end
-
-            serialized_data = association_serializer.serializable_object
-            key = association.root_key
-            if hash.has_key?(key)
-              hash[key].concat(serialized_data).uniq!
-            else
-              hash[key] = serialized_data
-            end
-          end
+      attributes.each_with_object({}) do |name, hash|
+        unless self.class._fragmented
+          hash[name] = send(name)
+        else
+          hash[name] = self.class._fragmented.public_send(name)
         end
       end
     end
 
-    def build_serializer(association)
-      object = send(association.name)
-      association.build_serializer(object, association_options_for_serializer(association))
-    end
-
-    def association_options_for_serializer(association)
-      prefix    = association.options[:prefix]
-      namespace = association.options[:namespace] || @namespace || self.namespace
+    def each_association(&block)
+      self.class._associations.dup.each do |name, association_options|
+        next unless object
+        association_value = send(name)
 
-      { scope: scope }.tap do |opts|
-        opts[:namespace] = namespace if namespace
-        opts[:prefix]    = prefix    if prefix
-      end
-    end
+        serializer_class = ActiveModel::Serializer.serializer_for(association_value, association_options)
 
-    def serialize(association,options={})
-      build_serializer(association).serializable_object(options)
-    end
+        if serializer_class
+          serializer = serializer_class.new(
+            association_value,
+            options.merge(serializer_from_options(association_options))
+          )
+        elsif !association_value.nil? && !association_value.instance_of?(Object)
+          association_options[:association_options][:virtual_value] = association_value
+        end
 
-    def serialize_ids(association)
-      associated_data = send(association.name)
-      if associated_data.respond_to?(:to_ary)
-        associated_data.map { |elem| serialize_id(elem, association) }
-      else
-        serialize_id(associated_data, association) if associated_data
+        if block_given?
+          block.call(name, serializer, association_options[:association_options])
+        end
       end
     end
 
-    def key_format
-      @key_format || self.class.key_format || CONFIG.key_format
+    def serializer_from_options(options)
+      opts = {}
+      serializer = options.fetch(:association_options, {}).fetch(:serializer, nil)
+      opts[:serializer] = serializer if serializer
+      opts
     end
 
-    def format_key(key)
-      if key_format == :lower_camel
-        key.to_s.camelize(:lower)
-      else
-        key
-      end
+    def self.serializers_cache
+      @serializers_cache ||= ThreadSafe::Cache.new
     end
 
-    def convert_keys(hash)
-      Hash[hash.map do |k,v|
-        key = if k.is_a?(Symbol)
-          format_key(k).to_sym
-        else
-          format_key(k)
-        end
+    private
 
-        [key ,v]
-      end]
-    end
-
-    attr_writer :serialization_options
-    def serialization_options
-      @serialization_options || {}
-    end
+    attr_reader :options
 
-    def serializable_object(options={})
-      self.serialization_options = options
-      return @wrap_in_array ? [] : nil if @object.nil?
-      hash = attributes
-      hash.merge! associations(options)
-      hash = convert_keys(hash) if key_format.present?
-      hash = { :type => type_name(@object), type_name(@object) => hash } if @polymorphic
-      @wrap_in_array ? [hash] : hash
-    end
-    alias_method :serializable_hash, :serializable_object
+    def self.get_serializer_for(klass)
+      serializers_cache.fetch_or_store(klass) do
+        serializer_class_name = "#{klass.name}Serializer"
+        serializer_class = serializer_class_name.safe_constantize
 
-    def serialize_id(elem, association)
-      id = elem.read_attribute_for_serialization(association.embed_key)
-      association.polymorphic? ? { id: id, type: type_name(elem) } : id
+        if serializer_class
+          serializer_class
+        elsif klass.superclass
+          get_serializer_for(klass.superclass)
+        end
+      end
     end
 
-    def type_name(elem)
-      elem.class.to_s.demodulize.underscore.to_sym
-    end
   end
-
 end