active_model_serializers 0.9.3 → 0.9.8

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

@@ -12,6 +12,10 @@ module ActiveModel
         include app.routes.url_helpers
       end
     end
+
+    config.to_prepare do
+      ActiveModel::Serializer.serializers_cache.clear
+    end
   end
 end
 

data/lib/active_model/serializer/version.rb

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

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

@@ -49,7 +49,27 @@ end
 
 class SpecialPost < Post
   def special_comment
-    @speical_comment ||= Comment.new(content: 'special')
+    @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
 
@@ -87,8 +107,24 @@ 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
+  has_one :user, serializer: UserSerializer
 end
 
 class ProfileSerializer < ActiveModel::Serializer
@@ -109,6 +145,13 @@ 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
 
@@ -169,7 +212,7 @@ end
 
 class NameKeyPostSerializer < ActiveModel::Serializer
   attributes :title, :body
-  
+
   has_many :comments
 end
 

data/test/integration/action_controller/namespaced_serialization_test.rb

@@ -19,6 +19,10 @@ module ActionController
         def render_comments
           render json: [Comment.new(content: 'Comment 1')]
         end
+
+        def render_hash
+          render json: {message: 'not found'}, status: 404
+        end
       end
 
       tests TestNamespace::MyController
@@ -42,6 +46,11 @@ module ActionController
         get :render_comments
         assert_serializer CommentSerializer
       end
+
+      def test_render_hash_regression
+        get :render_hash
+        assert_equal JSON.parse(response.body), {'message' => 'not found'}
+      end
     end
 
     class OptionNamespacedSerializationTest < ActionController::TestCase
@@ -93,4 +102,4 @@ module ActionController
     end
 
   end
-end
+end

data/test/integration/action_controller/serialization_test.rb

@@ -213,8 +213,8 @@ module ActionController
     class LowerCamelWoRootSerializerTest < ActionController::TestCase
       class WebLogController < ActionController::Base
         def render_without_root
-          render json: WebLog.new({name: 'Name 1', display_name: 'Display Name 1'}), 
-                 root: false, 
+          render json: WebLog.new({name: 'Name 1', display_name: 'Display Name 1'}),
+                 root: false,
                  serializer: WebLogLowerCamelSerializer
         end
       end
@@ -231,9 +231,9 @@ module ActionController
     class LowerCamelArrayWoRootSerializerTest < ActionController::TestCase
       class WebLogController < ActionController::Base
         def render_array_without_root
-          render json: [WebLog.new({name: 'Name 1', display_name: 'Display Name 1'}), 
-                        WebLog.new({name: 'Name 2', display_name: 'Display Name 2'})], 
-                 root: false, 
+          render json: [WebLog.new({name: 'Name 1', display_name: 'Display Name 1'}),
+                        WebLog.new({name: 'Name 2', display_name: 'Display Name 2'})],
+                 root: false,
                  each_serializer: WebLogLowerCamelSerializer
         end
       end