active_model_serializers 0.10.0.rc5 → 0.10.0

data/test/serializers/meta_test.rb

@@ -92,7 +92,7 @@ module ActiveModel
         assert_equal(expected, actual)
       end
 
-      def test_meta_key_is_used_with_json_api
+      def test_meta_key_is_not_used_with_json_api
         actual = ActiveModelSerializers::SerializableResource.new(
           @blog,
           adapter: :json_api,
@@ -105,18 +105,17 @@ module ActiveModel
             type: 'blogs',
             attributes: { title: 'AMS Hints' }
           },
-          'haha_meta' => { total: 10 }
+          meta: { total: 10 }
         }
         assert_equal(expected, actual)
       end
 
-      def test_meta_key_is_not_present_when_blank_object_with_json_api
+      def test_meta_key_is_not_present_when_empty_hash_with_json_api
         actual = ActiveModelSerializers::SerializableResource.new(
           @blog,
           adapter: :json_api,
           serializer: AlternateBlogSerializer,
-          meta: {},
-          meta_key: 'haha_meta'
+          meta: {}
         ).as_json
         expected = {
           data: {
@@ -133,8 +132,7 @@ module ActiveModel
           @blog,
           adapter: :json_api,
           serializer: AlternateBlogSerializer,
-          meta: '',
-          meta_key: 'haha_meta'
+          meta: ''
         ).as_json
         expected = {
           data: {

data/test/support/isolated_unit.rb

@@ -41,7 +41,6 @@ require 'active_support/core_ext/string/access'
 
 # These files do not require any others and are needed
 # to run the tests
-require 'active_support/testing/autorun'
 require 'active_support/testing/isolation'
 
 module TestHelpers

data/test/test_helper.rb

@@ -15,31 +15,29 @@ require 'action_controller'
 require 'action_controller/test_case'
 require 'action_controller/railtie'
 require 'active_model_serializers'
+# For now, we only restrict the options to serializable_hash/as_json/to_json
+# in tests, to ensure developers don't add any unsupported options.
+# There's no known benefit, at this time, to having the filtering run in
+# production when the excluded options would simply not be used.
+#
+# However, for documentation purposes, the constant
+# ActiveModel::Serializer::SERIALIZABLE_HASH_VALID_KEYS is defined
+# in the Serializer.
+ActiveModelSerializers::Adapter::Base.class_eval do
+  alias_method :original_serialization_options, :serialization_options
+
+  def serialization_options(options)
+    original_serialization_options(options)
+      .slice(*ActiveModel::Serializer::SERIALIZABLE_HASH_VALID_KEYS)
+  end
+end
 require 'fileutils'
 FileUtils.mkdir_p(File.expand_path('../../tmp/cache', __FILE__))
 
 gem 'minitest'
-begin
-  require 'minitest'
-rescue LoadError
-  # Minitest 4
-  require 'minitest/autorun'
-  $minitest_version = 4
-  # https://github.com/seattlerb/minitest/blob/644a52fd0/lib/minitest/autorun.rb
-  # https://github.com/seattlerb/minitest/blob/644a52fd0/lib/minitest/unit.rb#L768-L787
-  # Ensure backward compatibility with Minitest 4
-  Minitest = MiniTest unless defined?(Minitest)
-  Minitest::Test = MiniTest::Unit::TestCase
-else
-  # Minitest 5
-  require 'minitest/autorun'
-  $minitest_version = 5
-  # https://github.com/seattlerb/minitest/blob/e21fdda9d/lib/minitest/autorun.rb
-  # https://github.com/seattlerb/minitest/blob/e21fdda9d/lib/minitest.rb#L45-L59
-  # Filter out Minitest backtrace while allowing backtrace from other libraries
-  # to be shown.
-  Minitest.backtrace_filter = Minitest::BacktraceFilter.new
-end
+require 'minitest'
+require 'minitest/autorun'
+Minitest.backtrace_filter = Minitest::BacktraceFilter.new
 
 require 'support/rails_app'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_model_serializers
 version: !ruby/object:Gem::Version
-  version: 0.10.0.rc5
+  version: 0.10.0
 platform: ruby
 authors:
 - Steve Klabnik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-04 00:00:00.000000000 Z
+date: 2016-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -240,6 +240,7 @@ files:
 - docs/howto/add_root_key.md
 - docs/howto/outside_controller_use.md
 - docs/howto/passing_arbitrary_options.md
+- docs/howto/serialize_poro.md
 - docs/howto/test.md
 - docs/integrations/ember-and-json-api.md
 - docs/integrations/grape.md
@@ -297,11 +298,9 @@ files:
 - lib/active_model_serializers/adapter/json_api/relationship.rb
 - lib/active_model_serializers/adapter/json_api/resource_identifier.rb
 - lib/active_model_serializers/adapter/null.rb
-- lib/active_model_serializers/cached_serializer.rb
 - lib/active_model_serializers/callbacks.rb
 - lib/active_model_serializers/deprecate.rb
 - lib/active_model_serializers/deserialization.rb
-- lib/active_model_serializers/fragment_cache.rb
 - lib/active_model_serializers/json_pointer.rb
 - lib/active_model_serializers/key_transform.rb
 - lib/active_model_serializers/logging.rb
@@ -331,8 +330,6 @@ files:
 - test/action_controller/serialization_scope_name_test.rb
 - test/action_controller/serialization_test.rb
 - test/active_model_serializers/adapter_for_test.rb
-- test/active_model_serializers/cached_serializer_test.rb
-- test/active_model_serializers/fragment_cache_test.rb
 - test/active_model_serializers/json_pointer_test.rb
 - test/active_model_serializers/key_transform_test.rb
 - test/active_model_serializers/logging_test.rb
@@ -424,7 +421,7 @@ licenses:
 metadata: {}
 post_install_message: |
   NOTE: The default key case for the JsonApi adapter has changed to dashed.
-  See https://github.com/rails-api/active_model_serializers/blob/master/docs/general/key_transform.md
+  See https://github.com/rails-api/active_model_serializers/blob/master/docs/general/key_transforms.md
   for more information on configuring this behavior.
 rdoc_options: []
 require_paths:
@@ -436,12 +433,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Conventions-based JSON generation for Rails.
@@ -457,8 +454,6 @@ test_files:
 - test/action_controller/serialization_scope_name_test.rb
 - test/action_controller/serialization_test.rb
 - test/active_model_serializers/adapter_for_test.rb
-- test/active_model_serializers/cached_serializer_test.rb
-- test/active_model_serializers/fragment_cache_test.rb
 - test/active_model_serializers/json_pointer_test.rb
 - test/active_model_serializers/key_transform_test.rb
 - test/active_model_serializers/logging_test.rb

data/lib/active_model_serializers/cached_serializer.rb

@@ -1,87 +0,0 @@
-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/fragment_cache.rb

@@ -1,118 +0,0 @@
-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

data/test/active_model_serializers/cached_serializer_test.rb

@@ -1,80 +0,0 @@
-require 'test_helper'
-module ActiveModelSerializers
-  module Adapter
-    class CachedSerializerTest < ActiveSupport::TestCase
-      def test_cached_false_without_cache_store
-        cached_serializer = build do |serializer|
-          serializer._cache = nil
-        end
-        refute cached_serializer.cached?
-      end
-
-      def test_cached_true_with_cache_store_and_without_cache_only_and_cache_except
-        cached_serializer = build do |serializer|
-          serializer._cache = Object
-        end
-        assert cached_serializer.cached?
-      end
-
-      def test_cached_false_with_cache_store_and_with_cache_only
-        cached_serializer = build do |serializer|
-          serializer._cache = Object
-          serializer._cache_only = [:name]
-        end
-        refute cached_serializer.cached?
-      end
-
-      def test_cached_false_with_cache_store_and_with_cache_except
-        cached_serializer = build do |serializer|
-          serializer._cache = Object
-          serializer._cache_except = [:content]
-        end
-        refute cached_serializer.cached?
-      end
-
-      def test_fragment_cached_false_without_cache_store
-        cached_serializer = build do |serializer|
-          serializer._cache = nil
-          serializer._cache_only = [:name]
-        end
-        refute cached_serializer.fragment_cached?
-      end
-
-      def test_fragment_cached_true_with_cache_store_and_cache_only
-        cached_serializer = build do |serializer|
-          serializer._cache = Object
-          serializer._cache_only = [:name]
-        end
-        assert cached_serializer.fragment_cached?
-      end
-
-      def test_fragment_cached_true_with_cache_store_and_cache_except
-        cached_serializer = build do |serializer|
-          serializer._cache = Object
-          serializer._cache_except = [:content]
-        end
-        assert cached_serializer.fragment_cached?
-      end
-
-      def test_fragment_cached_false_with_cache_store_and_cache_except_and_cache_only
-        cached_serializer = build do |serializer|
-          serializer._cache = Object
-          serializer._cache_except = [:content]
-          serializer._cache_only = [:name]
-        end
-        refute cached_serializer.fragment_cached?
-      end
-
-      private
-
-      def build
-        serializer = Class.new(ActiveModel::Serializer)
-        serializer._cache_key = nil
-        serializer._cache_options = nil
-        yield serializer if block_given?
-        serializer_instance = serializer.new(Object)
-        CachedSerializer.new(serializer_instance)
-      end
-    end
-  end
-end