active_model_serializers 0.9.13 → 0.10.0.rc1

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

data/lib/active_model/serializer/version.rb

@@ -1,7 +1,5 @@
-# frozen_string_literal: true
-
 module ActiveModel
   class Serializer
-    VERSION = '0.9.13'
+    VERSION = "0.10.0.rc1"
   end
 end

data/lib/active_model/serializer.rb

@@ -1,341 +1,258 @@
-# frozen_string_literal: true
-
-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
-
-      def setup
-        @mutex.synchronize do
-          yield CONFIG
-        end
-      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 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 defined?(::ArraySerializer)
-            ::ArraySerializer
-          else
-            ArraySerializer
-          end
-        else
-          each_possible_serializer(resource, options) do |klass_name|
-            serializer = Serializer.serializers_cache.fetch_or_store(klass_name) do
-              _const_get(klass_name)
-            end
-            return serializer unless serializer.nil?
-          end
-          nil
-        end
-      end
-
-      attr_accessor :_root, :_attributes, :_associations
-      alias root  _root=
-      alias root= _root=
-
-      def root_name
-        if name
-          root_name = name.demodulize.underscore.sub(/_serializer$/, '')
-          CONFIG.plural_default_root ? root_name.pluralize : root_name
-        end
-      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 attributes(*attrs)
-        # Use `class_eval` rather than `define_method` for faster access
-        # and avoid retaining objects in the closure.
-        # Batch all methods in a single `class_eval` for efficiceny,
-        # and define all methods on the same line so the eventual backtrace
-        # properly maps to the `attributes` call.
-        source = ["# frozen_string_literal: true\n"]
-        attrs.each do |attr|
-          striped_attr = strip_attribute attr
-
-          @_attributes << striped_attr
-
-          unless method_defined?(attr)
-            source <<
-            "def #{striped_attr}" <<
-              "object.read_attribute_for_serialization(#{attr.inspect})" <<
-            "end" <<
-            "alias_method :#{striped_attr}, :#{striped_attr}" # suppress method redefinition warning
-          end
-        end
-        caller = caller_locations(1, 1).first
-        class_eval(source.join(";"), caller.path, caller.lineno - 1)
-      end
+    def self.inherited(base)
+      base._attributes = []
+      base._attributes_keys = {}
+      base._associations = {}
+      base._urls = []
+    end
 
-      def has_one(*attrs)
-        associate(Association::HasOne, *attrs)
-      end
+    def self.attributes(*attrs)
+      attrs = attrs.first if attrs.first.class == Array
+      @_attributes.concat attrs
 
-      def has_many(*attrs)
-        associate(Association::HasMany, *attrs)
+      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
 
-      def serializers_cache
-        @serializers_cache ||= Concurrent::Map.new
-      end
+    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
 
-      private
+    def self.fragmented(serializer)
+      @_fragmented = serializer
+    end
 
-      def strip_attribute(attr)
-        symbolized = attr.is_a?(Symbol)
+    # 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
 
-        attr = attr.to_s.gsub(/\?\Z/, '')
-        attr = attr.to_sym if symbolized
-        attr
-      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
 
-      def each_possible_serializer(resource, options)
-        yield build_serializer_class(resource, options)
-        yield build_serializer_class(resource, {})
-        yield build_serializer_class(resource.class.name.demodulize, {})
-      end
+    # 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
 
-      def build_serializer_class(resource, options)
-        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
+    # 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
 
-      def associate(klass, *attrs)
-        options = attrs.extract_options!
+    def self.associate(type, attrs) #:nodoc:
+      options = attrs.extract_options!
+      self._associations = _associations.dup
 
-        attrs.each do |attr|
+      attrs.each do |attr|
+        unless method_defined?(attr)
           define_method attr do
             object.send attr
-          end unless method_defined?(attr)
-
-          @_associations[attr] = klass.new(attr, options)
+          end
         end
+
+        self._associations[attr] = {type: type, association_options: options}
       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]
+    def self.url(attr)
+      @_urls.push attr
     end
-    attr_accessor :object, :scope, :root, :meta_key, :meta, :context, :polymorphic
-    attr_writer :key_format
 
-    def json_key
-      key = if root == true || root.nil?
-        self.class.root_name
-      else
-        root
-      end
-
-      key_format == :lower_camel && key.present? ? key.camelize(:lower) : key
+    def self.urls(*attrs)
+      @_urls.concat attrs
     end
 
-    def attributes
-      filter(self.class._attributes.dup).each_with_object({}) do |name, hash|
-        hash[name] = send(name)
+    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 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
+    def self.adapter
+      adapter_class = case config.adapter
+      when Symbol
+        ActiveModel::Serializer::Adapter.adapter_class(config.adapter)
+      when Class
+        config.adapter
       end
-    end
-
-    def filter(keys)
-      if @only
-        keys & @only
-      elsif @except
-        keys - @except
-      else
-        keys
+      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
+
+      adapter_class
     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
+    def self._root
+      @@root ||= false
+    end
 
-          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
-        end
-      end
+    def self._root=(root)
+      @@root = root
     end
 
-    def build_serializer(association)
-      object = send(association.name)
-      association.build_serializer(object, association_options_for_serializer(association))
+    def self.root_name
+      name.demodulize.underscore.sub(/_serializer$/, '') if name
     end
 
-    def association_options_for_serializer(association)
-      prefix    = association.options[:prefix]
-      namespace = association.options[:namespace] || @namespace || self.namespace
+    attr_accessor :object, :root, :meta, :meta_key, :scope
 
-      { scope: scope }.tap do |opts|
-        opts[:namespace] = namespace if namespace
-        opts[:prefix]    = prefix    if prefix
-      end
-    end
+    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]
 
-    def serialize(association,options={})
-      build_serializer(association).serializable_object(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 serialize_ids(association)
-      associated_data = send(association.name)
-      if associated_data.respond_to?(:to_ary)
-        associated_data.map { |elem| serialize_id(elem, association) }
+    def json_key
+      if root == true || root.nil?
+        self.class.root_name
       else
-        serialize_id(associated_data, association) if associated_data
+        root
       end
     end
 
-    def key_format
-      @key_format || self.class.key_format || CONFIG.key_format
+    def id
+      object.id if object
     end
 
-    def format_key(key)
-      if key_format == :lower_camel
-        key.to_s.camelize(:lower)
-      else
-        key
-      end
+    def type
+      object.class.to_s.demodulize.underscore.pluralize
     end
 
-    def convert_keys(hash)
-      Hash[hash.map do |k,v|
-        key = if k.is_a?(Symbol)
-          format_key(k).to_sym
+    def attributes(options = {})
+      attributes =
+        if options[:fields]
+          self.class._attributes & options[:fields]
         else
-          format_key(k)
+          self.class._attributes.dup
         end
 
-        [key ,v]
-      end]
+      attributes += options[:required_fields] if options[:required_fields]
+
+      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
 
-    attr_writer :serialization_options
-    def serialization_options
-      @serialization_options || {}
+    def each_association(&block)
+      self.class._associations.dup.each do |name, association_options|
+        next unless object
+        association_value = send(name)
+
+        serializer_class = ActiveModel::Serializer.serializer_for(association_value, association_options)
+
+        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
+
+        if block_given?
+          block.call(name, serializer, association_options[:association_options])
+        end
+      end
     end
 
-    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
+    def serializer_from_options(options)
+      opts = {}
+      serializer = options.fetch(:association_options, {}).fetch(:serializer, nil)
+      opts[:serializer] = serializer if serializer
+      opts
     end
-    alias_method :serializable_hash, :serializable_object
 
-    def serialize_id(elem, association)
-      id = elem.read_attribute_for_serialization(association.embed_key)
-      association.polymorphic? ? { id: id, type: type_name(elem) } : id
+    def self.serializers_cache
+      @serializers_cache ||= ThreadSafe::Cache.new
     end
 
-    def type_name(elem)
-      elem.class.to_s.demodulize.underscore.to_sym
+    private
+
+    attr_reader :options
+
+    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
+
+        if serializer_class
+          serializer_class
+        elsif klass.superclass
+          get_serializer_for(klass.superclass)
+        end
+      end
     end
-  end
 
+  end
 end

data/lib/active_model_serializers.rb

@@ -1,30 +1,16 @@
-# frozen_string_literal: true
-
 require 'active_model'
-require 'active_model/serializer'
-require 'active_model/serializer_support'
 require 'active_model/serializer/version'
-require 'active_model/serializer/railtie' if defined?(Rails)
+require 'active_model/serializer'
+require 'active_model/serializer/fieldset'
 
 begin
   require 'action_controller'
   require 'action_controller/serialization'
 
   ActiveSupport.on_load(:action_controller) do
-    if ::ActionController::Serialization.enabled
-      ActionController::Base.send(:include, ::ActionController::Serialization)
-
-      # action_controller_test_case load hook was added in Rails 5.1
-      # https://github.com/rails/rails/commit/0510208dd1ff23baa619884c0abcae4d141fae53
-      if ActiveSupport::VERSION::STRING < '5.1'
-        require 'action_controller/serialization_test_case'
-        ActionController::TestCase.send(:include, ::ActionController::SerializationAssertions)
-      else
-        ActiveSupport.on_load(:action_controller_test_case) do
-          require 'action_controller/serialization_test_case'
-          ActionController::TestCase.send(:include, ::ActionController::SerializationAssertions)
-        end
-      end
+    include ::ActionController::Serialization
+    ActionDispatch::Reloader.to_prepare do
+      ActiveModel::Serializer.serializers_cache.clear
     end
   end
 rescue LoadError

data/lib/generators/serializer/USAGE

@@ -0,0 +1,6 @@
+Description:
+    Generates a serializer for the given resource with tests.
+
+Example:
+    `rails generate serializer Account name created_at`
+

data/lib/{active_model/serializer/generators → generators}/serializer/serializer_generator.rb

@@ -1,14 +1,12 @@
-# frozen_string_literal: true
-
 module Rails
   module Generators
     class SerializerGenerator < NamedBase
-      source_root File.expand_path('../templates', __FILE__)
-      check_class_collision suffix: 'Serializer'
+      source_root File.expand_path("../templates", __FILE__)
+      check_class_collision :suffix => "Serializer"
 
-      argument :attributes, type: :array, default: [], banner: 'field:type field:type'
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
 
-      class_option :parent, type: :string, desc: 'The parent class for the generated serializer'
+      class_option :parent, :type => :string, :desc => "The parent class for the generated serializer"
 
       def create_serializer_file
         template 'serializer.rb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
@@ -27,13 +25,13 @@ module Rails
       def parent_class_name
         if options[:parent]
           options[:parent]
-        elsif (ns = Rails::Generators.namespace) && ns.const_defined?(:ApplicationSerializer) ||
-               (Object.const_get(:ApplicationSerializer) rescue nil)
-          'ApplicationSerializer'
+        elsif defined?(::ApplicationSerializer)
+          "ApplicationSerializer"
         else
-          'ActiveModel::Serializer'
+          "ActiveModel::Serializer"
         end
       end
     end
   end
 end
+

data/lib/{active_model/serializer/generators → generators}/serializer/templates/serializer.rb

@@ -1,8 +1,8 @@
 <% module_namespacing do -%>
 class <%= class_name %>Serializer < <%= parent_class_name %>
   attributes <%= attributes_names.map(&:inspect).join(", ") %>
+end
 <% association_names.each do |attribute| -%>
-  has_one :<%= attribute %>
+  attribute :<%= attribute %>
 <% end -%>
-end
 <% end -%>