active_model_serializers 0.10.0.rc2 → 0.10.0.rc3

data/lib/active_model/serializable_resource.rb

@@ -0,0 +1,70 @@
+require 'set'
+module ActiveModel
+  class SerializableResource
+    ADAPTER_OPTION_KEYS = Set.new([:include, :fields, :adapter])
+
+    # Primary interface to composing a resource with a serializer and adapter.
+    # @return the serializable_resource, ready for #as_json/#to_json/#serializable_hash.
+    def initialize(resource, options = {})
+      @resource = resource
+      @adapter_opts, @serializer_opts =
+        options.partition { |k, _| ADAPTER_OPTION_KEYS.include? k }.map { |h| Hash[h] }
+    end
+
+    delegate :serializable_hash, :as_json, :to_json, to: :adapter
+
+    def serialization_scope=(scope)
+      serializer_opts[:scope] = scope
+    end
+
+    def serialization_scope
+      serializer_opts[:scope]
+    end
+
+    def serialization_scope_name=(scope_name)
+      serializer_opts[:scope_name] = scope_name
+    end
+
+    def adapter
+      @adapter ||= ActiveModel::Serializer::Adapter.create(serializer_instance, adapter_opts)
+    end
+    alias_method :adapter_instance, :adapter
+
+    def serializer_instance
+      @serializer_instance ||= serializer.new(resource, serializer_opts)
+    end
+
+    # Get serializer either explicitly :serializer or implicitly from resource
+    # Remove :serializer key from serializer_opts
+    # Replace :serializer key with :each_serializer if present
+    def serializer
+      @serializer ||=
+        begin
+          @serializer = serializer_opts.delete(:serializer)
+          @serializer ||= ActiveModel::Serializer.serializer_for(resource)
+
+          if serializer_opts.key?(:each_serializer)
+            serializer_opts[:serializer] = serializer_opts.delete(:each_serializer)
+          end
+          @serializer
+        end
+    end
+    alias_method :serializer_class, :serializer
+
+    # True when no explicit adapter given, or explicit appear is truthy (non-nil)
+    # False when explicit adapter is falsy (nil or false)
+    def use_adapter?
+      !(adapter_opts.key?(:adapter) && !adapter_opts[:adapter])
+    end
+
+    def serializer?
+      use_adapter? && !!(serializer)
+    end
+
+    private
+
+    ActiveModelSerializers.silence_warnings do
+      attr_reader :resource, :adapter_opts, :serializer_opts
+    end
+  end
+end

data/lib/active_model/serializer.rb

@@ -3,16 +3,35 @@ require 'thread_safe'
 module ActiveModel
   class Serializer
     extend ActiveSupport::Autoload
+
     autoload :Configuration
     autoload :ArraySerializer
     autoload :Adapter
+    autoload :Lint
+    autoload :Associations
+    autoload :Fieldset
+    autoload :Utils
     include Configuration
+    include Associations
+
+    # Matches
+    #  "c:/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb:1:in `<top (required)>'"
+    #  AND
+    #  "/c/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb:1:in `<top (required)>'"
+    #  AS
+    #  c/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb
+    CALLER_FILE = /
+      \A       # start of string
+      \S+      # one or more non-spaces
+      (?=      # stop previous match when
+        :\d+     # a colon is followed by one or more digits
+        :in      # followed by a colon followed by in
+      )
+    /x
 
     class << self
       attr_accessor :_attributes
       attr_accessor :_attributes_keys
-      attr_accessor :_associations
-      attr_accessor :_urls
       attr_accessor :_cache
       attr_accessor :_fragmented
       attr_accessor :_cache_key
@@ -23,12 +42,10 @@ module ActiveModel
     end
 
     def self.inherited(base)
-      base._attributes = self._attributes.try(:dup)  || []
+      base._attributes = self._attributes.try(:dup) || []
       base._attributes_keys = self._attributes_keys.try(:dup) || {}
-      base._associations = self._associations.try(:dup) || {}
-      base._urls = []
-      serializer_file = File.open(caller.first[/^[^:]+/])
-      base._cache_digest = Digest::MD5.hexdigest(serializer_file.read)
+      base._cache_digest = digest_caller_file(caller.first)
+      super
     end
 
     def self.attributes(*attrs)
@@ -45,11 +62,14 @@ module ActiveModel
 
     def self.attribute(attr, options = {})
       key = options.fetch(:key, attr)
-      @_attributes_keys[attr] = {key: key} if key != attr
+      @_attributes_keys[attr] = { key: key } if key != attr
       @_attributes << key unless @_attributes.include?(key)
-      define_method key do
-        object.read_attribute_for_serialization(attr)
-      end unless method_defined?(key) || _fragmented.respond_to?(attr)
+
+      ActiveModelSerializers.silence_warnings do
+        define_method key do
+          object.read_attribute_for_serialization(attr)
+        end unless (key != :id && method_defined?(key)) || _fragmented.respond_to?(attr)
+      end
     end
 
     def self.fragmented(serializer)
@@ -58,91 +78,26 @@ module ActiveModel
 
     # 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 = 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
-
-    # 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
-
-    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
-
-        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 self.serializer_for(resource, options = {})
       if resource.respond_to?(:serializer_class)
         resource.serializer_class
       elsif resource.respond_to?(:to_ary)
         config.array_serializer
       else
-        options
-          .fetch(:association_options, {})
-          .fetch(:serializer, get_serializer_for(resource.class))
+        options.fetch(:serializer, get_serializer_for(resource.class))
       end
     end
 
+    # @see ActiveModel::Serializer::Adapter.lookup
     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
-
-      adapter_class
+      ActiveModel::Serializer::Adapter.lookup(config.adapter)
     end
 
     def self.root_name
@@ -152,12 +107,12 @@ module ActiveModel
     attr_accessor :object, :root, :meta, :meta_key, :scope
 
     def initialize(object, options = {})
-      @object     = object
-      @options    = options
-      @root       = options[:root]
-      @meta       = options[:meta]
-      @meta_key   = options[:meta_key]
-      @scope      = options[:scope]
+      @object = object
+      @options = options
+      @root = options[:root]
+      @meta = options[:meta]
+      @meta_key = options[:meta_key]
+      @scope = options[:scope]
 
       scope_name = options[:scope_name]
       if scope_name && !respond_to?(scope_name)
@@ -168,15 +123,7 @@ module ActiveModel
     end
 
     def json_key
-      self.class.root_name
-    end
-
-    def id
-      object.id if object
-    end
-
-    def type
-      object.class.model_name.plural
+      @root || object.class.model_name.to_s.underscore
     end
 
     def attributes(options = {})
@@ -187,8 +134,6 @@ module ActiveModel
           self.class._attributes.dup
         end
 
-      attributes += options[:required_fields] if options[:required_fields]
-
       attributes.each_with_object({}) do |name, hash|
         unless self.class._fragmented
           hash[name] = send(name)
@@ -198,40 +143,15 @@ module ActiveModel
       end
     end
 
-    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.except(:serializer).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 serializer_from_options(options)
-      opts = {}
-      serializer = options.fetch(:association_options, {}).fetch(:serializer, nil)
-      opts[:serializer] = serializer if serializer
-      opts
-    end
-
     def self.serializers_cache
       @serializers_cache ||= ThreadSafe::Cache.new
     end
 
-    private
+    def self.digest_caller_file(caller_line)
+      serializer_file_path = caller_line[CALLER_FILE]
+      serializer_file_contents = IO.read(serializer_file_path)
+      Digest::MD5.hexdigest(serializer_file_contents)
+    end
 
     attr_reader :options
 
@@ -247,6 +167,5 @@ module ActiveModel
         end
       end
     end
-
   end
 end

data/lib/active_model/serializer/adapter.rb

@@ -1,13 +1,84 @@
-require 'active_model/serializer/adapter/fragment_cache'
-
 module ActiveModel
   class Serializer
     class Adapter
+      UnknownAdapterError = Class.new(ArgumentError)
+      ADAPTER_MAP = {}
+      private_constant :ADAPTER_MAP if defined?(private_constant)
       extend ActiveSupport::Autoload
+      autoload :FragmentCache
       autoload :Json
-      autoload :FlattenJson
-      autoload :Null
       autoload :JsonApi
+      autoload :Null
+      autoload :FlattenJson
+
+      def self.create(resource, options = {})
+        override = options.delete(:adapter)
+        klass = override ? adapter_class(override) : ActiveModel::Serializer.adapter
+        klass.new(resource, options)
+      end
+
+      # @see ActiveModel::Serializer::Adapter.lookup
+      def self.adapter_class(adapter)
+        ActiveModel::Serializer::Adapter.lookup(adapter)
+      end
+
+      # Only the Adapter class has these methods.
+      # None of the sublasses have them.
+      class << ActiveModel::Serializer::Adapter
+        # @return Hash<adapter_name, adapter_class>
+        def adapter_map
+          ADAPTER_MAP
+        end
+
+        # @return [Array<Symbol>] list of adapter names
+        def adapters
+          adapter_map.keys.sort
+        end
+
+        # Adds an adapter 'klass' with 'name' to the 'adapter_map'
+        # Names are stringified and underscored
+        # @param [Symbol, String] name of the registered adapter
+        # @param [Class] klass - adapter class itself
+        # @example
+        #     AMS::Adapter.register(:my_adapter, MyAdapter)
+        def register(name, klass)
+          adapter_map.update(name.to_s.underscore => klass)
+          self
+        end
+
+        # @param  adapter [String, Symbol, Class] name to fetch adapter by
+        # @return [ActiveModel::Serializer::Adapter] subclass of Adapter
+        # @raise  [UnknownAdapterError]
+        def lookup(adapter)
+          # 1. return if is a class
+          return adapter if adapter.is_a?(Class)
+          adapter_name = adapter.to_s.underscore
+          # 2. return if registered
+          adapter_map.fetch(adapter_name) {
+            # 3. try to find adapter class from environment
+            adapter_class = find_by_name(adapter_name)
+            register(adapter_name, adapter_class)
+            adapter_class
+          }
+        rescue NameError, ArgumentError => e
+          failure_message =
+            "NameError: #{e.message}. Unknown adapter: #{adapter.inspect}. Valid adapters are: #{adapters}"
+          raise UnknownAdapterError, failure_message, e.backtrace
+        end
+
+        # @api private
+        def find_by_name(adapter_name)
+          adapter_name = adapter_name.to_s.classify.tr('API', 'Api')
+          ActiveModel::Serializer::Adapter.const_get(adapter_name.to_sym) or # rubocop:disable Style/AndOr
+            fail UnknownAdapterError
+        end
+        private :find_by_name
+      end
+
+      # Automatically register adapters when subclassing
+      def self.inherited(subclass)
+        ActiveModel::Serializer::Adapter.register(subclass.to_s.demodulize, subclass)
+      end
 
       attr_reader :serializer
 
@@ -16,33 +87,23 @@ module ActiveModel
         @options = options
       end
 
-      def serializable_hash(options = {})
+      def serializable_hash(options = nil)
         raise NotImplementedError, 'This is an abstract method. Should be implemented at the concrete adapter.'
       end
 
-      def as_json(options = {})
+      def as_json(options = nil)
         hash = serializable_hash(options)
-        include_meta(hash) unless self.class == FlattenJson
+        include_meta(hash)
         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)
+      def cache_check(serializer)
         @cached_serializer = serializer
         @klass             = @cached_serializer.class
         if is_cached?
@@ -68,11 +129,13 @@ module ActiveModel
         parts = []
         parts << object_cache_key
         parts << @klass._cache_digest unless @klass._cache_options && @klass._cache_options[:skip_digest]
-        parts.join("/")
+        parts.join('/')
       end
 
       def object_cache_key
-        (@klass._cache_key) ? "#{@klass._cache_key}/#{@cached_serializer.object.id}-#{@cached_serializer.object.updated_at}" : @cached_serializer.object.cache_key
+        object_time_safe = @cached_serializer.object.updated_at
+        object_time_safe = object_time_safe.strftime('%Y%m%d%H%M%S%9N') if object_time_safe.respond_to?(:strftime)
+        (@klass._cache_key) ? "#{@klass._cache_key}/#{@cached_serializer.object.id}-#{object_time_safe}" : @cached_serializer.object.cache_key
       end
 
       def meta
@@ -80,7 +143,7 @@ module ActiveModel
       end
 
       def meta_key
-        serializer.meta_key || "meta"
+        serializer.meta_key || 'meta'
       end
 
       def root