active_model_serializers 0.10.0.rc4 → 0.10.0.rc5

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

@@ -1,45 +0,0 @@
-module ActiveModel
-  class Serializer
-    module Adapter
-      class CachedSerializer
-        def initialize(serializer)
-          @cached_serializer = serializer
-          @klass             = @cached_serializer.class
-        end
-
-        def cache_check(adapter_instance)
-          if cached?
-            @klass._cache.fetch(cache_key, @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 && !@klass._cache_only && !@klass._cache_except
-        end
-
-        def fragment_cached?
-          @klass._cache_only && !@klass._cache_except || !@klass._cache_only && @klass._cache_except
-        end
-
-        def cache_key
-          parts = []
-          parts << object_cache_key
-          parts << @klass._cache_digest unless @klass._cache_options && @klass._cache_options[:skip_digest]
-          parts.join('/')
-        end
-
-        def 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
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-module ActiveModel
-  class Serializer
-    module Adapter
-      class FragmentCache
-        attr_reader :serializer
-
-        def initialize(adapter, serializer, options)
-          @instance_options = options
-          @adapter    = adapter
-          @serializer = serializer
-        end
-
-        # TODO: Use Serializable::Resource
-        # TODO: call +constantize+ less
-        # 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
-          klass = serializer.class
-          # It will split the serializer into two, one that will be cached and one that will not
-          serializers = fragment_serializer(serializer.object.class.name, klass)
-
-          # Instantiate 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, instance_options)
-          non_cached_adapter = adapter.class.new(non_cached_serializer, instance_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
-
-        protected
-
-        attr_reader :instance_options, :adapter
-
-        private
-
-        # Given a serializer class and 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 cached_attributes(klass, serializers)
-          attributes            = serializer.class._attributes
-          cached_attributes     = (klass._cache_only) ? klass._cache_only : attributes.reject { |attr| klass._cache_except.include?(attr) }
-          non_cached_attributes = attributes - cached_attributes
-
-          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
-
-        # Given a resource name and its serializer's class
-        # 1. Dyanmically creates a CachedSerializer and NonCachedSerializer
-        #   for a given class 'name'
-        # 2. Call
-        #       CachedSerializer.cache(serializer._cache_options)
-        #       CachedSerializer.fragmented(serializer)
-        #       NontCachedSerializer.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).
-        #     User_AdminCachedSerializer
-        #     User_AdminNOnCachedSerializer
-        #
-        def fragment_serializer(name, klass)
-          cached     = "#{to_valid_const_name(name)}CachedSerializer"
-          non_cached = "#{to_valid_const_name(name)}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
-
-        def to_valid_const_name(name)
-          name.gsub('::', '_')
-        end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module ActiveModel
-  class Serializer
-    module Adapter
-      class Json
-        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_api/deserialization.rb

@@ -1,207 +0,0 @@
-module ActiveModel
-  class Serializer
-    module Adapter
-      class JsonApi
-        # NOTE(Experimental):
-        # This is an experimental feature. Both the interface and internals could be subject
-        # to changes.
-        module Deserialization
-          InvalidDocument = Class.new(ArgumentError)
-
-          module_function
-
-          # Transform a JSON API document, containing a single data object,
-          # into a hash that is ready for ActiveRecord::Base.new() and such.
-          # Raises InvalidDocument if the payload is not properly formatted.
-          #
-          # @param [Hash|ActionController::Parameters] document
-          # @param [Hash] options
-          #   only: Array of symbols of whitelisted fields.
-          #   except: Array of symbols of blacklisted fields.
-          #   keys: Hash of translated keys (e.g. :author => :user).
-          #   polymorphic: Array of symbols of polymorphic fields.
-          # @return [Hash]
-          #
-          # @example
-          #   document = {
-          #     data: {
-          #       id: 1,
-          #       type: 'post',
-          #       attributes: {
-          #         title: 'Title 1',
-          #         date: '2015-12-20'
-          #       },
-          #       associations: {
-          #         author: {
-          #           data: {
-          #             type: 'user',
-          #             id: 2
-          #           }
-          #         },
-          #         second_author: {
-          #           data: nil
-          #         },
-          #         comments: {
-          #           data: [{
-          #             type: 'comment',
-          #             id: 3
-          #           },{
-          #             type: 'comment',
-          #             id: 4
-          #           }]
-          #         }
-          #       }
-          #     }
-          #   }
-          #
-          #   parse(document) #=>
-          #     # {
-          #     #   title: 'Title 1',
-          #     #   date: '2015-12-20',
-          #     #   author_id: 2,
-          #     #   second_author_id: nil
-          #     #   comment_ids: [3, 4]
-          #     # }
-          #
-          #   parse(document, only: [:title, :date, :author],
-          #                   keys: { date: :published_at },
-          #                   polymorphic: [:author]) #=>
-          #     # {
-          #     #   title: 'Title 1',
-          #     #   published_at: '2015-12-20',
-          #     #   author_id: '2',
-          #     #   author_type: 'people'
-          #     # }
-          #
-          def parse!(document, options = {})
-            parse(document, options) do |invalid_payload, reason|
-              fail InvalidDocument, "Invalid payload (#{reason}): #{invalid_payload}"
-            end
-          end
-
-          # Same as parse!, but returns an empty hash instead of raising InvalidDocument
-          # on invalid payloads.
-          def parse(document, options = {})
-            document = document.dup.permit!.to_h if document.is_a?(ActionController::Parameters)
-
-            validate_payload(document) do |invalid_document, reason|
-              yield invalid_document, reason if block_given?
-              return {}
-            end
-
-            primary_data = document['data']
-            attributes = primary_data['attributes'] || {}
-            attributes['id'] = primary_data['id'] if primary_data['id']
-            relationships = primary_data['relationships'] || {}
-
-            filter_fields(attributes, options)
-            filter_fields(relationships, options)
-
-            hash = {}
-            hash.merge!(parse_attributes(attributes, options))
-            hash.merge!(parse_relationships(relationships, options))
-
-            hash
-          end
-
-          # Checks whether a payload is compliant with the JSON API spec.
-          #
-          # @api private
-          # rubocop:disable Metrics/CyclomaticComplexity
-          def validate_payload(payload)
-            unless payload.is_a?(Hash)
-              yield payload, 'Expected hash'
-              return
-            end
-
-            primary_data = payload['data']
-            unless primary_data.is_a?(Hash)
-              yield payload, { data: 'Expected hash' }
-              return
-            end
-
-            attributes = primary_data['attributes'] || {}
-            unless attributes.is_a?(Hash)
-              yield payload, { data: { attributes: 'Expected hash or nil' } }
-              return
-            end
-
-            relationships = primary_data['relationships'] || {}
-            unless relationships.is_a?(Hash)
-              yield payload, { data: { relationships: 'Expected hash or nil' } }
-              return
-            end
-
-            relationships.each do |(key, value)|
-              unless value.is_a?(Hash) && value.key?('data')
-                yield payload, { data: { relationships: { key => 'Expected hash with :data key' } } }
-              end
-            end
-          end
-          # rubocop:enable Metrics/CyclomaticComplexity
-
-          # @api private
-          def filter_fields(fields, options)
-            if (only = options[:only])
-              fields.slice!(*Array(only).map(&:to_s))
-            elsif (except = options[:except])
-              fields.except!(*Array(except).map(&:to_s))
-            end
-          end
-
-          # @api private
-          def field_key(field, options)
-            (options[:keys] || {}).fetch(field.to_sym, field).to_sym
-          end
-
-          # @api private
-          def parse_attributes(attributes, options)
-            attributes
-              .map { |(k, v)| { field_key(k, options) => v } }
-              .reduce({}, :merge)
-          end
-
-          # Given an association name, and a relationship data attribute, build a hash
-          # mapping the corresponding ActiveRecord attribute to the corresponding value.
-          #
-          # @example
-          #   parse_relationship(:comments, [{ 'id' => '1', 'type' => 'comments' },
-          #                                  { 'id' => '2', 'type' => 'comments' }],
-          #                                 {})
-          #    # => { :comment_ids => ['1', '2'] }
-          #   parse_relationship(:author, { 'id' => '1', 'type' => 'users' }, {})
-          #    # => { :author_id => '1' }
-          #   parse_relationship(:author, nil, {})
-          #    # => { :author_id => nil }
-          # @param [Symbol] assoc_name
-          # @param [Hash] assoc_data
-          # @param [Hash] options
-          # @return [Hash{Symbol, Object}]
-          #
-          # @api private
-          def parse_relationship(assoc_name, assoc_data, options)
-            prefix_key = field_key(assoc_name, options).to_s.singularize
-            hash =
-              if assoc_data.is_a?(Array)
-                { "#{prefix_key}_ids".to_sym => assoc_data.map { |ri| ri['id'] } }
-              else
-                { "#{prefix_key}_id".to_sym => assoc_data ? assoc_data['id'] : nil }
-              end
-
-            polymorphic = (options[:polymorphic] || []).include?(assoc_name.to_sym)
-            hash.merge!("#{prefix_key}_type".to_sym => assoc_data['type']) if polymorphic
-
-            hash
-          end
-
-          # @api private
-          def parse_relationships(relationships, options)
-            relationships
-              .map { |(k, v)| parse_relationship(k, v['data'], options) }
-              .reduce({}, :merge)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module ActiveModel
-  class Serializer
-    module Adapter
-      class JsonApi
-        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].deep_merge(core_non_cached[1]) : core_non_cached[1]
-            hash = (root) ? { root => cached_resource } : cached_resource
-
-            hash.deep_merge no_root_non_cache.deep_merge no_root_cache
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-module ActiveModel
-  class Serializer
-    module Adapter
-      class JsonApi
-        class Link
-          def initialize(serializer, value)
-            @object = serializer.object
-            @scope = serializer.scope
-
-            # Use the return value of the block unless it is nil.
-            if value.respond_to?(:call)
-              @value = instance_eval(&value)
-            else
-              @value = value
-            end
-          end
-
-          def href(value)
-            @href = value
-            nil
-          end
-
-          def meta(value)
-            @meta = value
-            nil
-          end
-
-          def as_json
-            return @value if @value
-
-            hash = { href: @href }
-            hash.merge!(meta: @meta) if @meta
-
-            hash
-          end
-
-          protected
-
-          attr_reader :object, :scope
-        end
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-module ActiveModel
-  class Serializer
-    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 = {})
-            pages_from.each_with_object({}) do |(key, value), hash|
-              params = query_parameters.merge(page: { number: value, size: collection.size }).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
-end