active_model_serializers 0.10.0.rc4 → 0.10.0.rc5

data/lib/active_model_serializers/adapter/json_api/pagination_links.rb

@@ -0,0 +1,57 @@
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi < Base
+      class PaginationLinks
+        FIRST_PAGE = 1
+
+        attr_reader :collection, :context
+
+        def initialize(collection, context)
+          @collection = collection
+          @context = context
+        end
+
+        def serializable_hash(options = {})
+          per_page = collection.try(:per_page) || collection.try(:limit_value) || collection.size
+          pages_from.each_with_object({}) do |(key, value), hash|
+            params = query_parameters.merge(page: { number: value, size: per_page }).to_query
+
+            hash[key] = "#{url(options)}?#{params}"
+          end
+        end
+
+        private
+
+        def pages_from
+          return {} if collection.total_pages == FIRST_PAGE
+
+          {}.tap do |pages|
+            pages[:self] = collection.current_page
+
+            unless collection.current_page == FIRST_PAGE
+              pages[:first] = FIRST_PAGE
+              pages[:prev]  = collection.current_page - FIRST_PAGE
+            end
+
+            unless collection.current_page == collection.total_pages
+              pages[:next] = collection.current_page + FIRST_PAGE
+              pages[:last] = collection.total_pages
+            end
+          end
+        end
+
+        def url(options)
+          @url ||= options.fetch(:links, {}).fetch(:self, nil) || request_url
+        end
+
+        def request_url
+          @request_url ||= context.request_url
+        end
+
+        def query_parameters
+          @query_parameters ||= context.query_parameters
+        end
+      end
+    end
+  end
+end

data/lib/active_model_serializers/adapter/json_api/relationship.rb

@@ -0,0 +1,52 @@
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class Relationship
+        # {http://jsonapi.org/format/#document-resource-object-related-resource-links Document Resource Object Related Resource Links}
+        # {http://jsonapi.org/format/#document-links Document Links}
+        # {http://jsonapi.org/format/#document-resource-object-linkage Document Resource Relationship Linkage}
+        # {http://jsonapi.org/format/#document-meta Docment Meta}
+        def initialize(parent_serializer, serializer, serializable_resource_options, args = {})
+          @object = parent_serializer.object
+          @scope = parent_serializer.scope
+          @association_options = args.fetch(:options, {})
+          @serializable_resource_options = serializable_resource_options
+          @data = data_for(serializer)
+          @links = args.fetch(:links, {}).each_with_object({}) do |(key, value), hash|
+            hash[key] = ActiveModelSerializers::Adapter::JsonApi::Link.new(parent_serializer, value).as_json
+          end
+          meta = args.fetch(:meta, nil)
+          @meta = meta.respond_to?(:call) ? parent_serializer.instance_eval(&meta) : meta
+        end
+
+        def as_json
+          hash = {}
+          hash[:data] = data if association_options[:include_data]
+          links = self.links
+          hash[:links] = links if links.any?
+          meta = self.meta
+          hash[:meta] = meta if meta
+
+          hash
+        end
+
+        protected
+
+        attr_reader :object, :scope, :data, :serializable_resource_options,
+          :association_options, :links, :meta
+
+        private
+
+        def data_for(serializer)
+          if serializer.respond_to?(:each)
+            serializer.map { |s| ResourceIdentifier.new(s, serializable_resource_options).as_json }
+          elsif association_options[:virtual_value]
+            association_options[:virtual_value]
+          elsif serializer && serializer.object
+            ResourceIdentifier.new(serializer, serializable_resource_options).as_json
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_model_serializers/adapter/json_api/resource_identifier.rb

@@ -0,0 +1,37 @@
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class ResourceIdentifier
+        # {http://jsonapi.org/format/#document-resource-identifier-objects Resource Identifier Objects}
+        def initialize(serializer, options)
+          @id   = id_for(serializer)
+          @type = JsonApi.send(:transform_key_casing!, type_for(serializer),
+            options)
+        end
+
+        def as_json
+          { id: id, type: type }
+        end
+
+        protected
+
+        attr_reader :id, :type
+
+        private
+
+        def type_for(serializer)
+          return serializer._type if serializer._type
+          if ActiveModelSerializers.config.jsonapi_resource_type == :singular
+            serializer.object.class.model_name.singular
+          else
+            serializer.object.class.model_name.plural
+          end
+        end
+
+        def id_for(serializer)
+          serializer.read_attribute_for_serialization(:id).to_s
+        end
+      end
+    end
+  end
+end

data/lib/active_model_serializers/adapter/null.rb

@@ -0,0 +1,10 @@
+module ActiveModelSerializers
+  module Adapter
+    class Null < Base
+      # Since options param is not being used, underscored naming of the param
+      def serializable_hash(_options = nil)
+        {}
+      end
+    end
+  end
+end

data/lib/active_model_serializers/cached_serializer.rb

@@ -0,0 +1,87 @@
+module ActiveModelSerializers
+  class CachedSerializer
+    UndefinedCacheKey = Class.new(StandardError)
+
+    def initialize(serializer)
+      @cached_serializer = serializer
+      @klass             = @cached_serializer.class
+    end
+
+    def cache_check(adapter_instance)
+      if cached?
+        @klass._cache.fetch(cache_key(adapter_instance), @klass._cache_options) do
+          yield
+        end
+      elsif fragment_cached?
+        FragmentCache.new(adapter_instance, @cached_serializer, adapter_instance.instance_options).fetch
+      else
+        yield
+      end
+    end
+
+    def cached?
+      @klass.cache_enabled?
+    end
+
+    def fragment_cached?
+      @klass.fragment_cache_enabled?
+    end
+
+    def cache_key(adapter_instance)
+      return @cache_key if defined?(@cache_key)
+
+      parts = []
+      parts << object_cache_key
+      parts << adapter_instance.cached_name
+      parts << @klass._cache_digest unless @klass._skip_digest?
+      @cache_key = parts.join('/')
+    end
+
+    # Use object's cache_key if available, else derive a key from the object
+    # Pass the `key` option to the `cache` declaration or override this method to customize the cache key
+    def object_cache_key
+      if @cached_serializer.object.respond_to?(:cache_key)
+        @cached_serializer.object.cache_key
+      elsif (cache_key = (@klass._cache_key || @klass._cache_options[: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)
+        "#{cache_key}/#{@cached_serializer.object.id}-#{object_time_safe}"
+      else
+        fail UndefinedCacheKey, "#{@cached_serializer.object.class} must define #cache_key, or the 'key:' option must be passed into '#{@klass}.cache'"
+      end
+    end
+
+    # find all cache_key for the collection_serializer
+    # @param serializers [ActiveModel::Serializer::CollectionSerializer]
+    # @param adapter_instance [ActiveModelSerializers::Adapter::Base]
+    # @param include_tree [ActiveModel::Serializer::IncludeTree]
+    # @return [Array] all cache_key of collection_serializer
+    def self.object_cache_keys(serializers, adapter_instance, include_tree)
+      cache_keys = []
+
+      serializers.each do |serializer|
+        cache_keys << object_cache_key(serializer, adapter_instance)
+
+        serializer.associations(include_tree).each do |association|
+          if association.serializer.respond_to?(:each)
+            association.serializer.each do |sub_serializer|
+              cache_keys << object_cache_key(sub_serializer, adapter_instance)
+            end
+          else
+            cache_keys << object_cache_key(association.serializer, adapter_instance)
+          end
+        end
+      end
+
+      cache_keys.compact.uniq
+    end
+
+    # @return [String, nil] the cache_key of the serializer or nil
+    def self.object_cache_key(serializer, adapter_instance)
+      return unless serializer.present? && serializer.object.present?
+
+      cached_serializer = new(serializer)
+      cached_serializer.cached? ? cached_serializer.cache_key(adapter_instance) : nil
+    end
+  end
+end

data/lib/active_model_serializers/callbacks.rb

@@ -24,7 +24,7 @@ module ActiveModelSerializers
       # Defines a callback that will get called around the render method,
       # whether it is as_json, to_json, or serializable_hash
       #
-      #   class ActiveModel::SerializableResource
+      #   class ActiveModelSerializers::SerializableResource
       #     include ActiveModelSerializers::Callbacks
       #
       #     around_render do |args, block|

data/lib/active_model_serializers/deprecate.rb

@@ -0,0 +1,55 @@
+##
+# Provides a single method +deprecate+ to be used to declare when
+# something is going away.
+#
+#     class Legacy
+#       def self.klass_method
+#         # ...
+#       end
+#
+#       def instance_method
+#         # ...
+#       end
+#
+#       extend ActiveModelSerializers::Deprecate
+#       deprecate :instance_method, "ActiveModelSerializers::NewPlace#new_method"
+#
+#       class << self
+#         extend ActiveModelSerializers::Deprecate
+#         deprecate :klass_method, :none
+#       end
+#     end
+#
+# Adapted from https://github.com/rubygems/rubygems/blob/1591331/lib/rubygems/deprecate.rb
+module ActiveModelSerializers
+  module Deprecate
+    ##
+    # Simple deprecation method that deprecates +name+ by wrapping it up
+    # in a dummy method. It warns on each call to the dummy method
+    # telling the user of +replacement+ (unless +replacement+ is :none) that it is planned to go away.
+
+    def deprecate(name, replacement)
+      old = "_deprecated_#{name}"
+      alias_method old, name
+      class_eval do
+        define_method(name) do |*args, &block|
+          target = is_a?(Module) ? "#{self}." : "#{self.class}#"
+          msg = ["NOTE: #{target}#{name} is deprecated",
+                 replacement == :none ? ' with no replacement' : "; use #{replacement} instead",
+                 "\n#{target}#{name} called from #{ActiveModelSerializers.location_of_caller.join(":")}"
+                ]
+          warn "#{msg.join}."
+          send old, *args, &block
+        end
+      end
+    end
+
+    def delegate_and_deprecate(method, delegee)
+      delegate method, to: delegee
+      deprecate method, "#{delegee.name}."
+    end
+
+    module_function :deprecate
+    module_function :delegate_and_deprecate
+  end
+end

data/lib/active_model_serializers/deserialization.rb

@@ -3,11 +3,11 @@ module ActiveModelSerializers
     module_function
 
     def jsonapi_parse(*args)
-      ActiveModel::Serializer::Adapter::JsonApi::Deserialization.parse(*args)
+      Adapter::JsonApi::Deserialization.parse(*args)
     end
 
     def jsonapi_parse!(*args)
-      ActiveModel::Serializer::Adapter::JsonApi::Deserialization.parse!(*args)
+      Adapter::JsonApi::Deserialization.parse!(*args)
     end
   end
 end

data/lib/active_model_serializers/fragment_cache.rb

@@ -0,0 +1,118 @@
+module ActiveModelSerializers
+  class FragmentCache
+    attr_reader :serializer
+
+    def initialize(adapter, serializer, options)
+      @instance_options = options
+      @adapter    = adapter
+      @serializer = serializer
+    end
+
+    # 1. Create a CachedSerializer and NonCachedSerializer from the serializer class
+    # 2. Serialize the above two with the given adapter
+    # 3. Pass their serializations to the adapter +::fragment_cache+
+    def fetch
+      object = serializer.object
+
+      # It will split the serializer into two, one that will be cached and one that will not
+      serializers = fragment_serializer
+
+      # Get serializable hash from both
+      cached_hash     = serialize(object, serializers[:cached])
+      non_cached_hash = serialize(object, serializers[:non_cached])
+
+      # Merge both results
+      adapter.fragment_cache(cached_hash, non_cached_hash)
+    end
+
+    protected
+
+    attr_reader :instance_options, :adapter
+
+    private
+
+    def serialize(object, serializer_class)
+      SerializableResource.new(
+        object,
+        serializer: serializer_class,
+        adapter: adapter.class
+      ).serializable_hash
+    end
+
+    # Given a hash of its cached and non-cached serializers
+    # 1. Determine cached attributes from serializer class options
+    # 2. Add cached attributes to cached Serializer
+    # 3. Add non-cached attributes to non-cached Serializer
+    def cache_attributes(serializers)
+      klass                 = serializer.class
+      attributes            = klass._attributes
+      cache_only            = klass._cache_only
+      cached_attributes     = cache_only ? cache_only : attributes - klass._cache_except
+      non_cached_attributes = attributes - cached_attributes
+      attributes_keys       = klass._attributes_keys
+
+      add_attributes_to_serializer(serializers[:cached], cached_attributes, attributes_keys)
+      add_attributes_to_serializer(serializers[:non_cached], non_cached_attributes, attributes_keys)
+    end
+
+    def add_attributes_to_serializer(serializer, attributes, attributes_keys)
+      attributes.each do |attribute|
+        options = attributes_keys[attribute] || {}
+        serializer.attribute(attribute, options)
+      end
+    end
+
+    # Given a resource name
+    # 1. Dynamically creates a CachedSerializer and NonCachedSerializer
+    #   for a given class 'name'
+    # 2. Call
+    #       CachedSerializer.cache(serializer._cache_options)
+    #       CachedSerializer.fragmented(serializer)
+    #       NonCachedSerializer.cache(serializer._cache_options)
+    # 3. Build a hash keyed to the +cached+ and +non_cached+ serializers
+    # 4. Call +cached_attributes+ on the serializer class and the above hash
+    # 5. Return the hash
+    #
+    # @example
+    #   When +name+ is <tt>User::Admin</tt>
+    #   creates the Serializer classes (if they don't exist).
+    #     CachedUser_AdminSerializer
+    #     NonCachedUser_AdminSerializer
+    #
+    def fragment_serializer
+      klass                 = serializer.class
+      serializer_class_name = to_valid_const_name(klass.name)
+
+      cached     = "Cached#{serializer_class_name}"
+      non_cached = "NonCached#{serializer_class_name}"
+
+      cached_serializer     = get_or_create_serializer(cached)
+      non_cached_serializer = get_or_create_serializer(non_cached)
+
+      klass._cache_options ||= {}
+      cache_key = klass._cache_key
+      klass._cache_options[:key] = cache_key if cache_key
+      cached_serializer.cache(klass._cache_options)
+
+      type = klass._type
+      cached_serializer.type(type)
+      non_cached_serializer.type(type)
+
+      non_cached_serializer.fragmented(serializer)
+      cached_serializer.fragmented(serializer)
+
+      serializers = { cached: cached_serializer, non_cached: non_cached_serializer }
+      cache_attributes(serializers)
+      serializers
+    end
+
+    def get_or_create_serializer(name)
+      return Object.const_get(name) if Object.const_defined?(name)
+      Object.const_set(name, Class.new(ActiveModel::Serializer))
+    end
+
+    def to_valid_const_name(name)
+      name.gsub('::', '_')
+    end
+  end
+end