active_model_serializers 0.10.2 → 0.10.3

data/test/adapter/json_api/resource_identifier_test.rb

@@ -39,6 +39,26 @@ module ActiveModelSerializers
           test_type_inflection(AuthorSerializer, 'authors', :plural)
         end
 
+        def test_type_with_namespace
+          Object.const_set(:Admin, Module.new)
+          model = Class.new(::Model)
+          Admin.const_set(:PowerUser, model)
+          serializer = Class.new(ActiveModel::Serializer)
+          Admin.const_set(:PowerUserSerializer, serializer)
+          with_namespace_separator '--' do
+            admin_user = Admin::PowerUser.new
+            serializer = Admin::PowerUserSerializer.new(admin_user)
+            expected = {
+              id: admin_user.id,
+              type: 'admin--power-users'
+            }
+
+            identifier = ResourceIdentifier.new(serializer, {})
+            actual = identifier.as_json
+            assert_equal(expected, actual)
+          end
+        end
+
         def test_id_defined_on_object
           test_id(AuthorSerializer, @model.id.to_s)
         end

data/test/adapter/json_api/transform_test.rb

@@ -4,7 +4,10 @@ module ActiveModelSerializers
   module Adapter
     class JsonApi
       class KeyCaseTest < ActiveSupport::TestCase
-        Post = Class.new(::Model)
+        class Post < ::Model; end
+        class Author < ::Model; end
+        class Comment < ::Model; end
+
         class PostSerializer < ActiveModel::Serializer
           type 'posts'
           attributes :title, :body, :publish_at
@@ -23,13 +26,11 @@ module ActiveModelSerializers
           end
         end
 
-        Author = Class.new(::Model)
         class AuthorSerializer < ActiveModel::Serializer
           type 'authors'
           attributes :first_name, :last_name
         end
 
-        Comment = Class.new(::Model)
         class CommentSerializer < ActiveModel::Serializer
           type 'comments'
           attributes :body

data/test/benchmark/benchmarking_support.rb

@@ -36,7 +36,7 @@ module Benchmark
         version: ::ActiveModel::Serializer::VERSION.to_s,
         rails_version: ::Rails.version.to_s,
         iterations_per_second: entry.ips,
-        iterations_per_second_standard_deviation: entry.stddev_percentage,
+        iterations_per_second_standard_deviation: entry.error_percentage,
         total_allocated_objects_per_iteration: count_total_allocated_objects(&block)
       }.to_json
 

data/test/benchmark/bm_active_record.rb

@@ -0,0 +1,81 @@
+require_relative './benchmarking_support'
+require_relative './app'
+
+time = 10
+disable_gc = true
+
+# This is to disable any key transform effects that may impact performance
+ActiveModelSerializers.config.key_transform = :unaltered
+
+###########################################
+# Setup active record models
+##########################################
+require 'active_record'
+require 'sqlite3'
+
+# For debugging SQL output
+# ActiveRecord::Base.logger = Logger.new(STDERR)
+
+# Change the following to reflect your database settings
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: ':memory:'
+)
+
+# Don't show migration output when constructing fake db
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :authors, force: true do |t|
+    t.string :name
+  end
+
+  create_table :posts, force: true do |t|
+    t.text :body
+    t.string :title
+    t.references :author
+  end
+
+  create_table :profiles, force: true do |t|
+    t.text :project_url
+    t.text :bio
+    t.date :birthday
+    t.references :author
+  end
+end
+
+class Author < ActiveRecord::Base
+  has_one :profile
+  has_many :posts
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :author
+end
+
+class Profile < ActiveRecord::Base
+  belongs_to :author
+end
+
+# Build out the data to serialize
+author = Author.create(name: 'Preston Sego')
+Profile.create(project_url: 'https://github.com/NullVoxPopuli', author: author)
+50.times do
+  Post.create(
+    body: 'something about how password restrictions are evil, and less secure, and with the math to prove it.',
+    title: 'Your bank is does not know how to do security',
+    author: author
+  )
+end
+
+Benchmark.ams('AR: attributes', time: time, disable_gc: disable_gc) do
+  ActiveModelSerializers::SerializableResource.new(author, adapter: :attributes, include: 'profile,posts').serializable_hash
+end
+
+Benchmark.ams('AR: json', time: time, disable_gc: disable_gc) do
+  ActiveModelSerializers::SerializableResource.new(author, adapter: :json, include: 'profile,posts').serializable_hash
+end
+
+Benchmark.ams('AR: JSON API', time: time, disable_gc: disable_gc) do
+  ActiveModelSerializers::SerializableResource.new(author, adapter: :json_api, include: 'profile,posts').serializable_hash
+end

data/test/benchmark/bm_adapter.rb

@@ -0,0 +1,38 @@
+require_relative './benchmarking_support'
+require_relative './app'
+
+time = 10
+disable_gc = true
+ActiveModelSerializers.config.key_transform = :unaltered
+has_many_relationships = (0..60).map do |i|
+  HasManyRelationship.new(id: i, body: 'ZOMG A HAS MANY RELATIONSHIP')
+end
+has_one_relationship = HasOneRelationship.new(
+  id: 42,
+  first_name: 'Joao',
+  last_name: 'Moura'
+)
+primary_resource = PrimaryResource.new(
+  id: 1337,
+  title: 'New PrimaryResource',
+  virtual_attribute: nil,
+  body: 'Body',
+  has_many_relationships: has_many_relationships,
+  has_one_relationship: has_one_relationship
+)
+serializer = PrimaryResourceSerializer.new(primary_resource)
+
+Benchmark.ams('attributes', time: time, disable_gc: disable_gc) do
+  attributes = ActiveModelSerializers::Adapter::Attributes.new(serializer)
+  attributes.as_json
+end
+
+Benchmark.ams('json_api', time: time, disable_gc: disable_gc) do
+  json_api = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
+  json_api.as_json
+end
+
+Benchmark.ams('json', time: time, disable_gc: disable_gc) do
+  json = ActiveModelSerializers::Adapter::Json.new(serializer)
+  json.as_json
+end

data/test/benchmark/bm_caching.rb

@@ -4,7 +4,7 @@ require_relative './app'
 # https://github.com/ruby-bench/ruby-bench-suite/blob/8ad567f7e43a044ae48c36833218423bb1e2bd9d/rails/benchmarks/actionpack_router.rb
 class ApiAssertion
   include Benchmark::ActiveModelSerializers::TestMethods
-  BadRevisionError = Class.new(StandardError)
+  class BadRevisionError < StandardError; end
 
   def valid?
     caching = get_caching

data/test/benchmark/bm_lookup_chain.rb

@@ -0,0 +1,83 @@
+require_relative './benchmarking_support'
+require_relative './app'
+
+time = 10
+disable_gc = true
+ActiveModelSerializers.config.key_transform = :unaltered
+
+module AmsBench
+  module Api
+    module V1
+      class PrimaryResourceSerializer < ActiveModel::Serializer
+        attributes :title, :body
+
+        has_many :has_many_relationships
+      end
+
+      class HasManyRelationshipSerializer < ActiveModel::Serializer
+        attribute :body
+      end
+    end
+  end
+  class PrimaryResourceSerializer < ActiveModel::Serializer
+    attributes :title, :body
+
+    has_many :has_many_relationships
+
+    class HasManyRelationshipSerializer < ActiveModel::Serializer
+      attribute :body
+    end
+  end
+end
+
+resource = PrimaryResource.new(
+  id: 1,
+  title: 'title',
+  body: 'body',
+  has_many_relationships: [
+    HasManyRelationship.new(id: 1, body: 'body1'),
+    HasManyRelationship.new(id: 2, body: 'body1')
+  ]
+)
+
+serialization = lambda do
+  ActiveModelSerializers::SerializableResource.new(resource, serializer: AmsBench::PrimaryResourceSerializer).as_json
+  ActiveModelSerializers::SerializableResource.new(resource, namespace: AmsBench::Api::V1).as_json
+  ActiveModelSerializers::SerializableResource.new(resource).as_json
+end
+
+def clear_cache
+  AmsBench::PrimaryResourceSerializer.serializers_cache.clear
+  AmsBench::Api::V1::PrimaryResourceSerializer.serializers_cache.clear
+  ActiveModel::Serializer.serializers_cache.clear
+end
+
+configurable = lambda do
+  clear_cache
+  Benchmark.ams('Configurable Lookup Chain', time: time, disable_gc: disable_gc, &serialization)
+end
+
+old = lambda do
+  clear_cache
+  module ActiveModel
+    class Serializer
+      def self.serializer_lookup_chain_for(klass, namespace = nil)
+        chain = []
+
+        resource_class_name = klass.name.demodulize
+        resource_namespace = klass.name.deconstantize
+        serializer_class_name = "#{resource_class_name}Serializer"
+
+        chain.push("#{namespace}::#{serializer_class_name}") if namespace
+        chain.push("#{name}::#{serializer_class_name}") if self != ActiveModel::Serializer
+        chain.push("#{resource_namespace}::#{serializer_class_name}")
+        chain
+      end
+    end
+  end
+
+  Benchmark.ams('Old Lookup Chain (v0.10)', time: time, disable_gc: disable_gc, &serialization)
+end
+
+configurable.call
+old.call

data/test/cache_test.rb

@@ -4,22 +4,46 @@ require 'tempfile'
 
 module ActiveModelSerializers
   class CacheTest < ActiveSupport::TestCase
-    UncachedAuthor = Class.new(Author) do
+    # Instead of a primitive cache key (i.e. a string), this class
+    # returns a list of objects that require to be expanded themselves.
+    class AuthorWithExpandableCacheElements < Author
+      # For the test purposes it's important that #to_s for HasCacheKey differs
+      # between instances, hence not a Struct.
+      class HasCacheKey
+        attr_reader :cache_key
+        def initialize(cache_key)
+          @cache_key = cache_key
+        end
+
+        def to_s
+          "HasCacheKey##{object_id}"
+        end
+      end
+
+      def cache_key
+        [
+          HasCacheKey.new(name),
+          HasCacheKey.new(id)
+        ]
+      end
+    end
+
+    class UncachedAuthor < Author
       # To confirm cache_key is set using updated_at and cache_key option passed to cache
       undef_method :cache_key
     end
 
-    Article = Class.new(::Model) do
+    class Article < ::Model
       # To confirm error is raised when cache_key is not set and cache_key option not passed to cache
       undef_method :cache_key
     end
 
-    ArticleSerializer = Class.new(ActiveModel::Serializer) do
+    class ArticleSerializer < ActiveModel::Serializer
       cache only: [:place], skip_digest: true
       attributes :title
     end
 
-    InheritedRoleSerializer = Class.new(RoleSerializer) do
+    class InheritedRoleSerializer < RoleSerializer
       cache key: 'inherited_role', only: [:name, :special_attribute]
       attribute :special_attribute
     end
@@ -106,6 +130,20 @@ module ActiveModelSerializers
       assert_equal(uncached_author_serializer.attributes.to_json, cache_store.fetch(key).to_json)
     end
 
+    def test_cache_key_expansion
+      author = AuthorWithExpandableCacheElements.new(id: 10, name: 'hello')
+      same_author = AuthorWithExpandableCacheElements.new(id: 10, name: 'hello')
+      diff_author = AuthorWithExpandableCacheElements.new(id: 11, name: 'hello')
+
+      author_serializer = AuthorSerializer.new(author)
+      same_author_serializer = AuthorSerializer.new(same_author)
+      diff_author_serializer = AuthorSerializer.new(diff_author)
+      adapter = AuthorSerializer.serialization_adapter_instance
+
+      assert_equal(author_serializer.cache_key(adapter), same_author_serializer.cache_key(adapter))
+      refute_equal(author_serializer.cache_key(adapter), diff_author_serializer.cache_key(adapter))
+    end
+
     def test_default_cache_key_fallback
       render_object_with_cache(@comment)
       key = "#{@comment.cache_key}/#{adapter.cache_key}"

data/test/collection_serializer_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 module ActiveModel
   class Serializer
     class CollectionSerializerTest < ActiveSupport::TestCase
-      MessagesSerializer = Class.new(ActiveModel::Serializer) do
+      class MessagesSerializer < ActiveModel::Serializer
         type 'messages'
       end
 

data/test/fixtures/poro.rb

@@ -50,18 +50,18 @@ class ProfilePreviewSerializer < ActiveModel::Serializer
   attributes :name
 end
 
-Post     = Class.new(Model)
-Like     = Class.new(Model)
-Author   = Class.new(Model)
-Bio      = Class.new(Model)
-Blog     = Class.new(Model)
-Role     = Class.new(Model)
-User     = Class.new(Model)
-Location = Class.new(Model)
-Place    = Class.new(Model)
-Tag      = Class.new(Model)
-VirtualValue = Class.new(Model)
-Comment = Class.new(Model) do
+class Post < Model; end
+class Like < Model; end
+class Author < Model; end
+class Bio < Model; end
+class Blog < Model; end
+class Role < Model; end
+class User < Model; end
+class Location < Model; end
+class Place < Model; end
+class Tag < Model; end
+class VirtualValue < Model; end
+class Comment < Model
   # Uses a custom non-time-based cache key
   def cache_key
     "#{self.class.name.downcase}/#{id}"
@@ -87,10 +87,11 @@ class PolyTag < ActiveRecord::Base
   has_many :object_tags
 end
 
-module Spam; end
-Spam::UnrelatedLink = Class.new(Model)
+module Spam
+  class UnrelatedLink < Model; end
+end
 
-PostSerializer = Class.new(ActiveModel::Serializer) do
+class PostSerializer < ActiveModel::Serializer
   cache key: 'post', expires_in: 0.1, skip_digest: true
   attributes :id, :title, :body
 
@@ -108,12 +109,12 @@ PostSerializer = Class.new(ActiveModel::Serializer) do
   end
 end
 
-SpammyPostSerializer = Class.new(ActiveModel::Serializer) do
+class SpammyPostSerializer < ActiveModel::Serializer
   attributes :id
   has_many :related
 end
 
-CommentSerializer = Class.new(ActiveModel::Serializer) do
+class CommentSerializer < ActiveModel::Serializer
   cache expires_in: 1.day, skip_digest: true
   attributes :id, :body
 
@@ -125,7 +126,7 @@ CommentSerializer = Class.new(ActiveModel::Serializer) do
   end
 end
 
-AuthorSerializer = Class.new(ActiveModel::Serializer) do
+class AuthorSerializer < ActiveModel::Serializer
   cache key: 'writer', skip_digest: true
   attribute :id
   attribute :name
@@ -135,7 +136,7 @@ AuthorSerializer = Class.new(ActiveModel::Serializer) do
   has_one :bio
 end
 
-RoleSerializer = Class.new(ActiveModel::Serializer) do
+class RoleSerializer < ActiveModel::Serializer
   cache only: [:name, :slug], skip_digest: true
   attributes :id, :name, :description
   attribute :friendly_id, key: :slug
@@ -147,13 +148,13 @@ RoleSerializer = Class.new(ActiveModel::Serializer) do
   belongs_to :author
 end
 
-LikeSerializer = Class.new(ActiveModel::Serializer) do
+class LikeSerializer < ActiveModel::Serializer
   attributes :id, :time
 
   belongs_to :likeable
 end
 
-LocationSerializer = Class.new(ActiveModel::Serializer) do
+class LocationSerializer < ActiveModel::Serializer
   cache only: [:address], skip_digest: true
   attributes :id, :lat, :lng
 
@@ -164,20 +165,20 @@ LocationSerializer = Class.new(ActiveModel::Serializer) do
   end
 end
 
-PlaceSerializer = Class.new(ActiveModel::Serializer) do
+class PlaceSerializer < ActiveModel::Serializer
   attributes :id, :name
 
   has_many :locations
 end
 
-BioSerializer = Class.new(ActiveModel::Serializer) do
+class BioSerializer < ActiveModel::Serializer
   cache except: [:content], skip_digest: true
   attributes :id, :content, :rating
 
   belongs_to :author
 end
 
-BlogSerializer = Class.new(ActiveModel::Serializer) do
+class BlogSerializer < ActiveModel::Serializer
   cache key: 'blog'
   attributes :id, :name
 
@@ -185,50 +186,50 @@ BlogSerializer = Class.new(ActiveModel::Serializer) do
   has_many :articles
 end
 
-PaginatedSerializer = Class.new(ActiveModel::Serializer::CollectionSerializer) do
+class PaginatedSerializer < ActiveModel::Serializer::CollectionSerializer
   def json_key
     'paginated'
   end
 end
 
-AlternateBlogSerializer = Class.new(ActiveModel::Serializer) do
+class AlternateBlogSerializer < ActiveModel::Serializer
   attribute :id
   attribute :name, key: :title
 end
 
-CustomBlogSerializer = Class.new(ActiveModel::Serializer) do
+class CustomBlogSerializer < ActiveModel::Serializer
   attribute :id
   attribute :special_attribute
 
   has_many :articles
 end
 
-CommentPreviewSerializer = Class.new(ActiveModel::Serializer) do
+class CommentPreviewSerializer < ActiveModel::Serializer
   attributes :id
 
   belongs_to :post
 end
 
-AuthorPreviewSerializer = Class.new(ActiveModel::Serializer) do
+class AuthorPreviewSerializer < ActiveModel::Serializer
   attributes :id
 
   has_many :posts
 end
 
-PostPreviewSerializer = Class.new(ActiveModel::Serializer) do
+class PostPreviewSerializer < ActiveModel::Serializer
   attributes :title, :body, :id
 
   has_many :comments, serializer: CommentPreviewSerializer
   belongs_to :author, serializer: AuthorPreviewSerializer
 end
 
-PostWithTagsSerializer = Class.new(ActiveModel::Serializer) do
+class PostWithTagsSerializer < ActiveModel::Serializer
   attributes :id
 
   has_many :tags
 end
 
-PostWithCustomKeysSerializer = Class.new(ActiveModel::Serializer) do
+class PostWithCustomKeysSerializer < ActiveModel::Serializer
   attributes :id
 
   has_many :comments, key: :reviews
@@ -236,7 +237,7 @@ PostWithCustomKeysSerializer = Class.new(ActiveModel::Serializer) do
   has_one :blog, key: :site
 end
 
-VirtualValueSerializer = Class.new(ActiveModel::Serializer) do
+class VirtualValueSerializer < ActiveModel::Serializer
   attributes :id
 
   has_many :reviews, virtual_value: [{ type: 'reviews', id: '1' },
@@ -250,34 +251,36 @@ VirtualValueSerializer = Class.new(ActiveModel::Serializer) do
   end
 end
 
-PolymorphicHasManySerializer = Class.new(ActiveModel::Serializer) do
+class PolymorphicHasManySerializer < ActiveModel::Serializer
   attributes :id, :name
 end
 
-PolymorphicBelongsToSerializer = Class.new(ActiveModel::Serializer) do
+class PolymorphicBelongsToSerializer < ActiveModel::Serializer
   attributes :id, :title
 
   has_one :imageable, serializer: PolymorphicHasManySerializer, polymorphic: true
 end
 
-PolymorphicSimpleSerializer = Class.new(ActiveModel::Serializer) do
+class PolymorphicSimpleSerializer < ActiveModel::Serializer
   attributes :id
 end
 
-PolymorphicObjectTagSerializer = Class.new(ActiveModel::Serializer) do
+class PolymorphicObjectTagSerializer < ActiveModel::Serializer
   attributes :id
 
   has_many :taggable, serializer: PolymorphicSimpleSerializer, polymorphic: true
 end
 
-PolymorphicTagSerializer = Class.new(ActiveModel::Serializer) do
+class PolymorphicTagSerializer < ActiveModel::Serializer
   attributes :id, :phrase
 
   has_many :object_tags, serializer: PolymorphicObjectTagSerializer
 end
 
-Spam::UnrelatedLinkSerializer = Class.new(ActiveModel::Serializer) do
-  cache only: [:id]
-  attributes :id
+module Spam
+  class UnrelatedLinkSerializer < ActiveModel::Serializer
+    cache only: [:id]
+    attributes :id
+  end
 end
 $VERBOSE = verbose