active_model_serializers 0.10.0.rc4 → 0.10.0.rc5

data/lib/active_model_serializers/json_pointer.rb

@@ -0,0 +1,14 @@
+module ActiveModelSerializers
+  module JsonPointer
+    module_function
+
+    POINTERS = {
+      attribute:    '/data/attributes/%s'.freeze,
+      primary_data: '/data%s'.freeze
+    }.freeze
+
+    def new(pointer_type, value = nil)
+      format(POINTERS[pointer_type], value)
+    end
+  end
+end

data/lib/active_model_serializers/key_transform.rb

@@ -0,0 +1,70 @@
+require 'active_support/core_ext/hash/keys'
+
+module ActiveModelSerializers
+  module KeyTransform
+    module_function
+
+    # Transforms values to UpperCamelCase or PascalCase.
+    #
+    # @example:
+    #    "some_key" => "SomeKey",
+    # @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L66-L76 ActiveSupport::Inflector.camelize}
+    def camel(value)
+      case value
+      when Hash then value.deep_transform_keys! { |key| camel(key) }
+      when Symbol then camel(value.to_s).to_sym
+      when String then value.underscore.camelize
+      else value
+      end
+    end
+
+    # Transforms values to camelCase.
+    #
+    # @example:
+    #    "some_key" => "someKey",
+    # @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L66-L76 ActiveSupport::Inflector.camelize}
+    def camel_lower(value)
+      case value
+      when Hash then value.deep_transform_keys! { |key| camel_lower(key) }
+      when Symbol then camel_lower(value.to_s).to_sym
+      when String then value.underscore.camelize(:lower)
+      else value
+      end
+    end
+
+    # Transforms values to dashed-case.
+    # This is the default case for the JsonApi adapter.
+    #
+    # @example:
+    #    "some_key" => "some-key",
+    # @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L185-L187 ActiveSupport::Inflector.dasherize}
+    def dash(value)
+      case value
+      when Hash then value.deep_transform_keys! { |key| dash(key) }
+      when Symbol then dash(value.to_s).to_sym
+      when String then value.underscore.dasherize
+      else value
+      end
+    end
+
+    # Transforms values to underscore_case.
+    # This is the default case for deserialization in the JsonApi adapter.
+    #
+    # @example:
+    #    "some-key" => "some_key",
+    # @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L89-L98 ActiveSupport::Inflector.underscore}
+    def underscore(value)
+      case value
+      when Hash then value.deep_transform_keys! { |key| underscore(key) }
+      when Symbol then underscore(value.to_s).to_sym
+      when String then value.underscore
+      else value
+      end
+    end
+
+    # Returns the value unaltered
+    def unaltered(value)
+      value
+    end
+  end
+end

data/lib/active_model_serializers/logging.rb

@@ -81,7 +81,10 @@ module ActiveModelSerializers
     end
 
     def notify_render_payload
-      { serializer: serializer, adapter: adapter }
+      {
+        serializer: serializer || ActiveModel::Serializer::Null,
+        adapter: adapter || ActiveModelSerializers::Adapter::Null
+      }
     end
 
     private

data/lib/active_model_serializers/model.rb

@@ -6,10 +6,11 @@ module ActiveModelSerializers
     include ActiveModel::Model
     include ActiveModel::Serializers::JSON
 
-    attr_reader :attributes
+    attr_reader :attributes, :errors
 
     def initialize(attributes = {})
       @attributes = attributes
+      @errors = ActiveModel::Errors.new(self)
       super
     end
 
@@ -35,5 +36,14 @@ module ActiveModelSerializers
         attributes[key]
       end
     end
+
+    # The following methods are needed to be minimally implemented for ActiveModel::Errors
+    def self.human_attribute_name(attr, _options = {})
+      attr
+    end
+
+    def self.lookup_ancestors
+      [self]
+    end
   end
 end

data/lib/active_model_serializers/railtie.rb

@@ -15,13 +15,21 @@ module ActiveModelSerializers
       end
     end
 
+    initializer 'active_model_serializers.prepare_serialization_context' do
+      SerializationContext.url_helpers = Rails.application.routes.url_helpers
+      SerializationContext.default_url_options = Rails.application.routes.default_url_options
+    end
+
     # This hook is run after the action_controller railtie has set the configuration
     # based on the *environment* configuration and before any config/initializers are run
     # and also before eager_loading (if enabled).
     initializer 'active_model_serializers.set_configs', :after => 'action_controller.set_configs' do
       ActiveModelSerializers.logger = Rails.configuration.action_controller.logger
-      ActiveModelSerializers.config.cache_store     = Rails.configuration.action_controller.cache_store
       ActiveModelSerializers.config.perform_caching = Rails.configuration.action_controller.perform_caching
+      # We want this hook to run after the config has been set, even if ActionController has already loaded.
+      ActiveSupport.on_load(:action_controller) do
+        ActiveModelSerializers.config.cache_store = ActionController::Base.cache_store
+      end
     end
 
     generators do |app|

data/lib/active_model_serializers/register_jsonapi_renderer.rb

@@ -0,0 +1,64 @@
+# Based on discussion in https://github.com/rails/rails/pull/23712#issuecomment-184977238,
+# the JSON API media type will have its own format/renderer.
+#
+# > We recommend the media type be registered on its own as jsonapi
+# when a jsonapi Renderer and deserializer (Http::Parameters::DEFAULT_PARSERS) are added.
+#
+# Usage:
+#
+# ActiveSupport.on_load(:action_controller) do
+#   require 'active_model_serializers/register_jsonapi_renderer'
+# end
+#
+# And then in controllers, use `render jsonapi: model` rather than `render json: model, adapter: :json_api`.
+#
+# For example, in a controller action, we can:
+# respond_to do |format|
+#   format.jsonapi { render jsonapi: model }
+# end
+#
+# or
+#
+# render jsonapi: model
+#
+# No wrapper format needed as it does not apply (i.e. no `wrap_parameters format: [jsonapi]`)
+
+module ActiveModelSerializers::Jsonapi
+  MEDIA_TYPE = 'application/vnd.api+json'.freeze
+  HEADERS = {
+    response: { 'CONTENT_TYPE'.freeze => MEDIA_TYPE },
+    request:  { 'ACCEPT'.freeze => MEDIA_TYPE }
+  }.freeze
+  module ControllerSupport
+    def serialize_jsonapi(json, options)
+      options[:adapter] = :json_api
+      options.fetch(:serialization_context) { options[:serialization_context] = ActiveModelSerializers::SerializationContext.new(request) }
+      get_serializer(json, options)
+    end
+  end
+end
+
+# actionpack/lib/action_dispatch/http/mime_types.rb
+Mime::Type.register ActiveModelSerializers::Jsonapi::MEDIA_TYPE, :jsonapi
+
+parsers = Rails::VERSION::MAJOR >= 5 ? ActionDispatch::Http::Parameters : ActionDispatch::ParamsParser
+media_type = Mime::Type.lookup(ActiveModelSerializers::Jsonapi::MEDIA_TYPE)
+
+# Proposal: should actually deserialize the JSON API params
+# to the hash format expected by `ActiveModel::Serializers::JSON`
+# actionpack/lib/action_dispatch/http/parameters.rb
+parsers::DEFAULT_PARSERS[media_type] = lambda do |body|
+  data = JSON.parse(body)
+  data = { :_json => data } unless data.is_a?(Hash)
+  data.with_indifferent_access
+end
+
+# ref https://github.com/rails/rails/pull/21496
+ActionController::Renderers.add :jsonapi do |json, options|
+  json = serialize_jsonapi(json, options).to_json(options) unless json.is_a?(String)
+  self.content_type ||= media_type
+  headers.merge! ActiveModelSerializers::Jsonapi::HEADERS[:response]
+  self.response_body = json
+end
+
+ActionController::Base.send :include, ActiveModelSerializers::Jsonapi::ControllerSupport

data/lib/active_model_serializers/serializable_resource.rb

@@ -0,0 +1,81 @@
+require 'set'
+
+module ActiveModelSerializers
+  class SerializableResource
+    ADAPTER_OPTION_KEYS = Set.new([:include, :fields, :adapter, :meta, :meta_key, :links])
+    include ActiveModelSerializers::Logging
+
+    delegate :serializable_hash, :as_json, :to_json, to: :adapter
+    notify :serializable_hash, :render
+    notify :as_json, :render
+    notify :to_json, :render
+
+    # 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
+
+    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
+
+    # NOTE: if no adapter is available, returns the resource itself. (i.e. adapter is a no-op)
+    def adapter
+      @adapter ||= find_adapter
+    end
+    alias adapter_instance adapter
+
+    def find_adapter
+      return resource unless serializer?
+      ActiveModelSerializers::Adapter.create(serializer_instance, adapter_opts)
+    rescue ActiveModel::Serializer::CollectionSerializer::NoSerializerError
+      resource
+    end
+
+    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 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.nil?
+    end
+
+    protected
+
+    attr_reader :resource, :adapter_opts, :serializer_opts
+  end
+end

data/lib/active_model_serializers/serialization_context.rb

@@ -1,10 +1,32 @@
 module ActiveModelSerializers
   class SerializationContext
-    attr_reader :request_url, :query_parameters
+    class << self
+      attr_writer :url_helpers, :default_url_options
+      def url_helpers
+        @url_helpers ||= Module.new
+      end
 
-    def initialize(request)
+      def default_url_options
+        @default_url_options ||= {}
+      end
+    end
+    module UrlHelpers
+      def self.included(base)
+        base.send(:include, SerializationContext.url_helpers)
+      end
+
+      def default_url_options
+        SerializationContext.default_url_options
+      end
+    end
+
+    attr_reader :request_url, :query_parameters, :key_transform
+
+    def initialize(request, options = {})
       @request_url = request.original_url[/\A[^?]+/]
       @query_parameters = request.query_parameters
+      @url_helpers = options.delete(:url_helpers) || self.class.url_helpers
+      @default_url_options = options.delete(:default_url_options) || self.class.default_url_options
     end
   end
 end

data/lib/active_model_serializers/test/schema.rb

@@ -2,8 +2,8 @@ module ActiveModelSerializers
   module Test
     module Schema
       # A Minitest Assertion that test the response is valid against a schema.
-      # @params schema_path [String] a custom schema path
-      # @params message [String] a custom error message
+      # @param schema_path [String] a custom schema path
+      # @param message [String] a custom error message
       # @return [Boolean] true when the response is valid
       # @return [Minitest::Assertion] when the response is invalid
       # @example

data/lib/grape/formatters/active_model_serializers.rb

@@ -8,7 +8,7 @@ module Grape
       def self.call(resource, env)
         serializer_options = {}
         serializer_options.merge!(env[:active_model_serializer_options]) if env[:active_model_serializer_options]
-        ActiveModel::SerializableResource.new(resource, serializer_options).to_json
+        ::ActiveModelSerializers::SerializableResource.new(resource, serializer_options).to_json
       end
     end
   end

data/test/action_controller/adapter_selector_test.rb

@@ -36,7 +36,7 @@ module ActionController
             type: 'profiles',
             attributes: {
               name: 'Name 1',
-              description: 'Description 1',
+              description: 'Description 1'
             }
           }
         }

data/test/action_controller/json_api/deserialization_test.rb

@@ -9,10 +9,50 @@ module ActionController
             parsed_hash = ActiveModelSerializers::Deserialization.jsonapi_parse(params)
             render json: parsed_hash
           end
+
+          def render_polymorphic_parsed_payload
+            parsed_hash = ActiveModelSerializers::Deserialization.jsonapi_parse(
+              params,
+              polymorphic: [:restriction_for, :restricted_to]
+            )
+            render json: parsed_hash
+          end
         end
 
         tests DeserializationTestController
 
+        def test_deserialization_of_relationship_only_object
+          hash = {
+            'data' => {
+              'type' => 'restraints',
+              'relationships' => {
+                'restriction_for' => {
+                  'data' => {
+                    'type' => 'discounts',
+                    'id' => '67'
+                  }
+                },
+                'restricted_to' => {
+                  'data' => nil
+                }
+              }
+            },
+            'restraint' => {}
+          }
+
+          post :render_polymorphic_parsed_payload, params: hash
+
+          response = JSON.parse(@response.body)
+          expected = {
+            'restriction_for_id' => '67',
+            'restriction_for_type' => 'discounts',
+            'restricted_to_id' => nil,
+            'restricted_to_type' => nil
+          }
+
+          assert_equal(expected, response)
+        end
+
         def test_deserialization
           hash = {
             'data' => {
@@ -20,7 +60,10 @@ module ActionController
               'id' => 'zorglub',
               'attributes' => {
                 'title' => 'Ember Hamster',
-                'src' => 'http://example.com/images/productivity.png'
+                'src' => 'http://example.com/images/productivity.png',
+                'image-width' => '200',
+                'imageHeight' => '200',
+                'ImageSize' => '1024'
               },
               'relationships' => {
                 'author' => {
@@ -34,21 +77,31 @@ module ActionController
                     { 'type' => 'comments', 'id' => '1' },
                     { 'type' => 'comments', 'id' => '2' }
                   ]
+                },
+                'related-images' => {
+                  'data' => [
+                    { 'type' => 'image', 'id' => '7' },
+                    { 'type' => 'image', 'id' => '8' }
+                  ]
                 }
               }
             }
           }
 
-          post :render_parsed_payload, hash
+          post :render_parsed_payload, params: hash
 
           response = JSON.parse(@response.body)
           expected = {
             'id' => 'zorglub',
             'title' => 'Ember Hamster',
             'src' => 'http://example.com/images/productivity.png',
+            'image_width' => '200',
+            'image_height' => '200',
+            'image_size' => '1024',
             'author_id' => nil,
             'photographer_id' => '9',
-            'comment_ids' => %w(1 2)
+            'comment_ids' => %w(1 2),
+            'related_image_ids' => %w(7 8)
           }
 
           assert_equal(expected, response)