active_model_serializers 0.8.3 → 0.10.15

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi < Base
+      class PaginationLinks
+        MissingSerializationContextError = Class.new(KeyError)
+        FIRST_PAGE = 1
+
+        attr_reader :collection, :context
+
+        def initialize(collection, adapter_options)
+          @collection = collection
+          @adapter_options = adapter_options
+          @context = adapter_options.fetch(:serialization_context) do
+            fail MissingSerializationContextError, <<-EOF.freeze
+ JsonApi::PaginationLinks requires a ActiveModelSerializers::SerializationContext.
+ Please pass a ':serialization_context' option or
+ override CollectionSerializer#paginated? to return 'false'.
+            EOF
+          end
+        end
+
+        def as_json
+          {
+            self:  location_url,
+            first: first_page_url,
+            prev:  prev_page_url,
+            next:  next_page_url,
+            last:  last_page_url
+          }
+        end
+
+        protected
+
+        attr_reader :adapter_options
+
+        private
+
+        def location_url
+          url_for_page(collection.current_page)
+        end
+
+        def first_page_url
+          url_for_page(1)
+        end
+
+        def last_page_url
+          if collection.total_pages == 0
+            url_for_page(FIRST_PAGE)
+          else
+            url_for_page(collection.total_pages)
+          end
+        end
+
+        def prev_page_url
+          return nil if collection.current_page == FIRST_PAGE
+          if collection.current_page > collection.total_pages
+            return url_for_page(collection.total_pages)
+          end
+          url_for_page(collection.current_page - FIRST_PAGE)
+        end
+
+        def next_page_url
+          return nil if collection.total_pages == 0 ||
+              collection.current_page >= collection.total_pages
+          url_for_page(collection.next_page)
+        end
+
+        def url_for_page(number)
+          params = query_parameters.dup
+          params[:page] = { size: per_page, number: number }
+          "#{url(adapter_options)}?#{params.to_query}"
+        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
+
+        def per_page
+          @per_page ||= collection.try(:per_page) || collection.try(:limit_value) || collection.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+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 Document Meta}
+        def initialize(parent_serializer, serializable_resource_options, association)
+          @parent_serializer = parent_serializer
+          @association = association
+          @serializable_resource_options = serializable_resource_options
+        end
+
+        def as_json
+          hash = {}
+
+          hash[:data] = data_for(association) if association.include_data?
+
+          links = links_for(association)
+          hash[:links] = links if links.any?
+
+          meta = meta_for(association)
+          hash[:meta] = meta if meta
+          hash[:meta] = {} if hash.empty?
+
+          hash
+        end
+
+        protected
+
+        attr_reader :parent_serializer, :serializable_resource_options, :association
+
+        private
+
+        # TODO(BF): Avoid db hit on belong_to_ releationship by using foreign_key on self
+        def data_for(association)
+          if association.collection?
+            data_for_many(association)
+          else
+            data_for_one(association)
+          end
+        end
+
+        def data_for_one(association)
+          if belongs_to_id_on_self?(association)
+            id = parent_serializer.read_attribute_for_serialization(association.reflection.foreign_key)
+            type =
+              if association.polymorphic?
+                # We can't infer resource type for polymorphic relationships from the serializer.
+                # We can ONLY know a polymorphic resource type by inspecting each resource.
+                association.lazy_association.serializer.json_key
+              else
+                association.reflection.type.to_s
+              end
+            ResourceIdentifier.for_type_with_id(type, id, serializable_resource_options)
+          else
+            # TODO(BF): Process relationship without evaluating lazy_association
+            serializer = association.lazy_association.serializer
+            if (virtual_value = association.virtual_value)
+              virtual_value
+            elsif serializer && association.object
+              ResourceIdentifier.new(serializer, serializable_resource_options).as_json
+            else
+              nil
+            end
+          end
+        end
+
+        def data_for_many(association)
+          # TODO(BF): Process relationship without evaluating lazy_association
+          collection_serializer = association.lazy_association.serializer
+          if collection_serializer.respond_to?(:each)
+            collection_serializer.map do |serializer|
+              ResourceIdentifier.new(serializer, serializable_resource_options).as_json
+            end
+          elsif (virtual_value = association.virtual_value)
+            virtual_value
+          else
+            []
+          end
+        end
+
+        def links_for(association)
+          association.links.each_with_object({}) do |(key, value), hash|
+            result = Link.new(parent_serializer, value).as_json
+            hash[key] = result if result
+          end
+        end
+
+        def meta_for(association)
+          meta = association.meta
+          meta.respond_to?(:call) ? parent_serializer.instance_eval(&meta) : meta
+        end
+
+        def belongs_to_id_on_self?(association)
+          parent_serializer.config.jsonapi_use_foreign_key_on_belongs_to_relationship &&
+            association.belongs_to? &&
+            parent_serializer.object.respond_to?(association.reflection.foreign_key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class ResourceIdentifier
+        def self.type_for(serializer, serializer_type = nil, transform_options = {})
+          raw_type = serializer_type ? serializer_type : raw_type_from_serializer_object(serializer.object)
+          JsonApi.send(:transform_key_casing!, raw_type, transform_options)
+        end
+
+        def self.for_type_with_id(type, id, options)
+          type = inflect_type(type)
+          type = type_for(:no_class_needed, type, options)
+          if id.blank?
+            nil
+          else
+            { id: id.to_s, type: type }
+          end
+        end
+
+        def self.raw_type_from_serializer_object(object)
+          class_name = object.class.name # should use model_name
+          raw_type = class_name.underscore
+          raw_type = inflect_type(raw_type)
+          raw_type
+            .gsub!('/'.freeze, ActiveModelSerializers.config.jsonapi_namespace_separator)
+          raw_type
+        end
+
+        def self.inflect_type(type)
+          singularize = ActiveModelSerializers.config.jsonapi_resource_type == :singular
+          inflection = singularize ? :singularize : :pluralize
+          ActiveSupport::Inflector.public_send(inflection, type)
+        end
+
+        # {http://jsonapi.org/format/#document-resource-identifier-objects Resource Identifier Objects}
+        def initialize(serializer, options)
+          @id   = id_for(serializer)
+          @type = type_for(serializer, options)
+        end
+
+        def as_json
+          if id.blank?
+            { type: type }
+          else
+            { id: id.to_s, type: type }
+          end
+        end
+
+        protected
+
+        attr_reader :id, :type
+
+        private
+
+        def type_for(serializer, transform_options)
+          serializer_type = serializer._type
+          self.class.type_for(serializer, serializer_type, transform_options)
+        end
+
+        def id_for(serializer)
+          serializer.read_attribute_for_serialization(:id).to_s
+        end
+      end
+    end
+  end
+end