active_model_serializers 0.9.0 → 0.9.8

data/lib/active_model/serializer/association/has_many.rb

@@ -0,0 +1,39 @@
+module ActiveModel
+  class Serializer
+    class Association
+      class HasMany < Association
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key.to_s
+          @key ||= case CONFIG.default_key_type
+            when :name then name.to_s.pluralize
+            else "#{name.to_s.singularize}_ids"
+          end
+        end
+
+        def serializer_class(object, _)
+          if use_array_serializer?
+            ArraySerializer
+          else
+            serializer_from_options
+          end
+        end
+
+        def options
+          if use_array_serializer?
+            { each_serializer: serializer_from_options }.merge! super
+          else
+            super
+          end
+        end
+
+        private
+
+        def use_array_serializer?
+          !serializer_from_options ||
+            serializer_from_options && !(serializer_from_options <= ArraySerializer)
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/association/has_one.rb

@@ -0,0 +1,25 @@
+module ActiveModel
+  class Serializer
+    class Association
+      class HasOne < Association
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key.to_s.pluralize
+          @key ||= case CONFIG.default_key_type
+            when :name then name.to_s.singularize
+            else "#{name}_id"
+          end
+        end
+
+        def serializer_class(object, options = {})
+          (serializer_from_options unless object.nil?) || serializer_from_object(object, options) || default_serializer
+        end
+
+        def build_serializer(object, options = {})
+          options[:_wrap_in_array] = embed_in_root?
+          super
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/generators/serializer/scaffold_controller_generator.rb

@@ -7,7 +7,7 @@ module Rails
       if Rails::VERSION::MAJOR >= 4
         source_root File.expand_path('../templates', __FILE__)
 
-        hook_for :serializer, default: true
+        hook_for :serializer, default: true, type: :boolean
       end
     end
   end

data/lib/active_model/serializer/railtie.rb

@@ -6,5 +6,17 @@ module ActiveModel
       require 'active_model/serializer/generators/serializer/scaffold_controller_generator'
       require 'active_model/serializer/generators/resource_override'
     end
+
+    initializer 'include_routes.active_model_serializer' do |app|
+      ActiveSupport.on_load(:active_model_serializers) do
+        include app.routes.url_helpers
+      end
+    end
+
+    config.to_prepare do
+      ActiveModel::Serializer.serializers_cache.clear
+    end
   end
 end
+
+ActiveSupport.run_load_hooks(:active_model_serializers, ActiveModel::Serializer)

data/lib/active_model/serializer/version.rb

@@ -1,5 +1,5 @@
 module ActiveModel
   class Serializer
-    VERSION = '0.9.0'
+    VERSION = '0.9.8'.freeze
   end
 end

data/lib/active_model_serializers.rb

@@ -9,7 +9,7 @@ begin
   require 'action_controller/serialization'
   require 'action_controller/serialization_test_case'
 
-  ActiveSupport.on_load(:after_initialize) do
+  ActiveSupport.on_load(:action_controller) do
     if ::ActionController::Serialization.enabled
       ActionController::Base.send(:include, ::ActionController::Serialization)
       ActionController::TestCase.send(:include, ::ActionController::SerializationAssertions)

data/lib/active_model_serializers/model/caching.rb

@@ -0,0 +1,25 @@
+module ActiveModelSerializers
+  class Model
+    module Caching
+      extend ActiveSupport::Concern
+
+      included do
+        attr_writer :updated_at
+        attributes :id
+      end
+
+      # Defaults to the downcased model name and updated_at
+      def cache_key
+        ActiveSupport::Cache.expand_cache_key([
+          self.class.model_name.name.downcase,
+          "#{id}-#{updated_at.strftime('%Y%m%d%H%M%S%9N')}"
+        ].compact)
+      end
+
+      # Defaults to the time the serializer file was modified.
+      def updated_at
+        defined?(@updated_at) ? @updated_at : File.mtime(__FILE__)
+      end
+    end
+  end
+end

data/test/benchmark/app.rb

@@ -0,0 +1,60 @@
+# https://github.com/rails-api/active_model_serializers/pull/872
+# approx ref 792fb8a9053f8db3c562dae4f40907a582dd1720 to test against
+require 'bundler/setup'
+
+require 'rails'
+require 'active_model'
+require 'active_support'
+require 'active_support/json'
+require 'action_controller'
+require 'action_controller/test_case'
+require 'action_controller/railtie'
+abort "Rails application already defined: #{Rails.application.class}" if Rails.application
+
+class NullLogger < Logger
+  def initialize(*_args)
+  end
+
+  def add(*_args, &_block)
+  end
+end
+class BenchmarkLogger < ActiveSupport::Logger
+  def initialize
+    @file = StringIO.new
+    super(@file)
+  end
+
+  def messages
+    @file.rewind
+    @file.read
+  end
+end
+# ref: https://gist.github.com/bf4/8744473
+class BenchmarkApp < Rails::Application
+  # Set up production configuration
+  config.eager_load = true
+  config.cache_classes = true
+  # CONFIG: CACHE_ON={on,off}
+  config.action_controller.perform_caching = ENV['CACHE_ON'] != 'off'
+  config.action_controller.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
+
+  config.active_support.test_order = :random
+  config.secret_token = 'S' * 30
+  config.secret_key_base = 'abc123'
+  config.consider_all_requests_local = false
+
+  # otherwise deadlock occurred
+  config.middleware.delete 'Rack::Lock'
+
+  # to disable log files
+  config.logger = NullLogger.new
+  config.active_support.deprecation = :log
+  config.log_level = :info
+end
+
+require 'active_model_serializers'
+
+# Initialize app before any serializers are defined, for running across revisions.
+# ref: https://github.com/rails-api/active_model_serializers/pull/1478
+Rails.application.initialize!
+

data/test/benchmark/benchmarking_support.rb

@@ -0,0 +1,67 @@
+require 'benchmark/ips'
+require 'json'
+
+# Add benchmarking runner from ruby-bench-suite
+# https://github.com/ruby-bench/ruby-bench-suite/blob/master/rails/benchmarks/support/benchmark_rails.rb
+module Benchmark
+  module ActiveModelSerializers
+    module TestMethods
+      def request(method, path)
+        response = Rack::MockRequest.new(BenchmarkApp).send(method, path)
+        if response.status.in?([404, 500])
+          fail "omg, #{method}, #{path}, '#{response.status}', '#{response.body}'"
+        end
+        response
+      end
+    end
+
+    # extend Benchmark with an `ams` method
+    def ams(label = nil, time:, disable_gc: true, warmup: 3, &block)
+      fail ArgumentError.new, 'block should be passed' unless block_given?
+
+      if disable_gc
+        GC.disable
+      else
+        GC.enable
+      end
+
+      report = Benchmark.ips(time, warmup, true) do |x|
+        x.report(label) { yield }
+      end
+
+      entry = report.entries.first
+
+      output = {
+        label: label,
+        version: ::ActiveModel::Serializer::VERSION.to_s,
+        rails_version: ::Rails.version.to_s,
+        iterations_per_second: entry.ips,
+        iterations_per_second_standard_deviation: entry.error_percentage,
+        total_allocated_objects_per_iteration: count_total_allocated_objects(&block)
+      }.to_json
+
+      puts output
+      output
+    end
+
+    def count_total_allocated_objects
+      if block_given?
+        key =
+          if RUBY_VERSION < '2.2'
+            :total_allocated_object
+          else
+            :total_allocated_objects
+          end
+
+        before = GC.stat[key]
+        yield
+        after = GC.stat[key]
+        after - before
+      else
+        -1
+      end
+    end
+  end
+
+  extend Benchmark::ActiveModelSerializers
+end

data/test/benchmark/bm_active_record.rb

@@ -0,0 +1,41 @@
+require_relative './benchmarking_support'
+require_relative './app'
+require_relative './setup'
+
+time = 10
+disable_gc = true
+
+
+
+authors_query = Author.preload(:posts).preload(:profile)
+author = authors_query.first
+authors = authors_query.to_a
+
+
+Benchmark.ams('Single: DefaultSerializer', time: time, disable_gc: disable_gc) do
+ ActiveModel::DefaultSerializer.new(author).to_json
+end
+
+Benchmark.ams('ArraySerializer', time: time, disable_gc: disable_gc) do
+ ActiveModel::ArraySerializer.new(authors).to_json
+end
+
+Benchmark.ams('ArraySerializer: each_serializer: DefaultSerializer', time: time, disable_gc: disable_gc) do
+ ActiveModel::ArraySerializer.new(authors, each_serializer:ActiveModel::DefaultSerializer).to_json
+end
+
+Benchmark.ams('FlatAuthorSerializer', time: time, disable_gc: disable_gc) do
+ FlatAuthorSerializer.new(author).to_json
+end
+
+Benchmark.ams('ArraySerializer: each_serializer: FlatAuthorSerializer', time: time, disable_gc: disable_gc) do
+ ActiveModel::ArraySerializer.new(authors, each_serializer: FlatAuthorSerializer).to_json
+end
+
+Benchmark.ams('AuthorWithDefaultRelationshipsSerializer', time: time, disable_gc: disable_gc) do
+ AuthorWithDefaultRelationshipsSerializer.new(author).to_json
+end
+
+Benchmark.ams('ArraySerializer: each_serializer: AuthorWithDefaultRelationshipsSerializer', time: time, disable_gc: disable_gc) do
+ ActiveModel::ArraySerializer.new(authors, each_serializer: AuthorWithDefaultRelationshipsSerializer).to_json
+end

data/test/benchmark/setup.rb

@@ -0,0 +1,75 @@
+###########################################
+# Setup active record models
+##########################################
+require 'active_record'
+require 'sqlite3'
+
+
+# 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
+
+ActiveModel::Serializer.root = false
+ActiveModel::ArraySerializer.root = false
+
+class FlatAuthorSerializer < ActiveModel::Serializer
+  attributes :id, :name
+end
+
+class AuthorWithDefaultRelationshipsSerializer < ActiveModel::Serializer
+  attributes :id, :name
+
+  has_one :profile
+  has_many :posts
+end
+
+# For debugging SQL output
+#ActiveRecord::Base.logger = Logger.new(STDERR)

data/test/fixtures/active_record.rb

@@ -74,6 +74,10 @@ class ARSectionSerializer < ActiveModel::Serializer
   attributes 'name'
 end
 
+class AREmbeddedSerializer < ActiveModel::Serializer
+  has_many :ar_tags, :ar_comments
+end
+
 ARPost.create(title: 'New post',
               body:  'A body!!!',
               ar_section: ARSection.create(name: 'ruby')).tap do |post|

data/test/fixtures/poro.rb

@@ -1,11 +1,13 @@
 class Model
-  def initialize(hash={})
+  def initialize(hash = {})
     @attributes = hash
   end
 
   def read_attribute_for_serialization(name)
     if name == :id || name == 'id'
       object_id
+    elsif respond_to?(name)
+      send name
     else
       @attributes[name]
     end
@@ -22,9 +24,22 @@ class User < Model
   end
 end
 
+class UserInfo < Model
+  def user
+    @user ||= User.new(name: 'N1', email: 'E1')
+  end
+end
+
 class Profile < Model
 end
 
+class Category < Model
+  def posts
+    @posts ||= [Post.new(title: 'T1', body: 'B1'),
+                Post.new(title: 'T2', body: 'B2')]
+  end
+end
+
 class Post < Model
   def comments
     @comments ||= [Comment.new(content: 'C1'),
@@ -32,12 +47,57 @@ class Post < Model
   end
 end
 
+class SpecialPost < Post
+  def special_comment
+    @special_comment ||= Comment.new(content: 'special')
+  end
+end
+
+class Type < Model
+end
+
+class SelfReferencingUser < Model
+  def type
+    @type ||= Type.new(name: 'N1')
+  end
+  def parent
+    @parent ||= SelfReferencingUserParent.new(name: 'N1')
+  end
+end
+
+class SelfReferencingUserParent < Model
+  def type
+    @type ||= Type.new(name: 'N2')
+  end
+  def parent
+  end
+end
+
 class Comment < Model
 end
 
 class WebLog < Model
 end
 
+class Interview < Model
+  def attachment
+    @attachment ||= Image.new(url: 'U1')
+  end
+end
+
+class Mail < Model
+  def attachments
+    @attachments ||= [Image.new(url: 'U1'),
+                      Video.new(html: 'H1')]
+  end
+end
+
+class Image < Model
+end
+
+class Video < Model
+end
+
 ###
 ## Serializers
 ###
@@ -47,6 +107,26 @@ class UserSerializer < ActiveModel::Serializer
   has_one :profile
 end
 
+class TypeSerializer < ActiveModel::Serializer
+  attributes :name
+end
+
+class SelfReferencingUserParentSerializer < ActiveModel::Serializer
+  attributes :name
+  has_one :type, serializer: TypeSerializer, embed: :ids, include: true
+end
+
+class SelfReferencingUserSerializer < ActiveModel::Serializer
+  attributes :name
+
+  has_one :type, serializer: TypeSerializer, embed: :ids, include: true
+  has_one :parent, serializer: SelfReferencingUserSerializer, embed: :ids, include: true
+end
+
+class UserInfoSerializer < ActiveModel::Serializer
+  has_one :user, serializer: UserSerializer
+end
+
 class ProfileSerializer < ActiveModel::Serializer
   def description
     description = object.read_attribute_for_serialization(:description)
@@ -56,12 +136,31 @@ class ProfileSerializer < ActiveModel::Serializer
   attributes :name, :description
 end
 
+class CategorySerializer < ActiveModel::Serializer
+  attributes :name
+
+  has_many :posts
+end
+
 class PostSerializer < ActiveModel::Serializer
   attributes :title, :body
 
+  def title
+    keyword = serialization_options[:highlight_keyword]
+    title = object.read_attribute_for_serialization(:title)
+    title = title.gsub(keyword,"'#{keyword}'") if keyword
+    title
+  end
+
   has_many :comments
 end
 
+class SpecialPostSerializer < ActiveModel::Serializer
+  attributes :title, :body
+  has_many :comments, root: :comments, embed_in_root: true, embed: :ids
+  has_one :special_comment, root: :comments, embed_in_root: true, embed: :ids
+end
+
 class CommentSerializer < ActiveModel::Serializer
   attributes :content
 end
@@ -73,3 +172,52 @@ end
 class WebLogLowerCamelSerializer < WebLogSerializer
   format_keys :lower_camel
 end
+
+class InterviewSerializer < ActiveModel::Serializer
+  attributes :text
+
+  has_one :attachment, polymorphic: true
+end
+
+class MailSerializer < ActiveModel::Serializer
+  attributes :body
+
+  has_many :attachments, polymorphic: true
+end
+
+class ImageSerializer < ActiveModel::Serializer
+  attributes :url
+end
+
+class VideoSerializer < ActiveModel::Serializer
+  attributes :html
+end
+
+class ShortProfileSerializer < ::ProfileSerializer; end
+
+module TestNamespace
+  class ProfileSerializer < ::ProfileSerializer; end
+  class UserSerializer    < ::UserSerializer;    end
+end
+
+ActiveModel::Serializer.setup do |config|
+  config.default_key_type = :name
+end
+
+class NameKeyUserSerializer < ActiveModel::Serializer
+  attributes :name, :email
+
+  has_one :profile
+end
+
+class NameKeyPostSerializer < ActiveModel::Serializer
+  attributes :title, :body
+
+  has_many :comments
+end
+
+ActiveModel::Serializer.setup do |config|
+  config.default_key_type = nil
+end
+
+