surrealist 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a5a2bfdc5cbfe0e1a5f8fbc9e8213da087e2d149ac40857bf8a7e3730c52b87
-  data.tar.gz: 9b28deb85b05ba4a6baf61eb0b9d52f5746fc9d819765175dd74dd45fae53f3d
+  metadata.gz: a430c1d28309d9ef1c1626e64fa3e0f482abef0215307a8ac8ea19083a44eb8b
+  data.tar.gz: dc45cc49c8b1af7676a9ad6738c42c83e10397587d7d21908d5345ee74248ff4
 SHA512:
-  metadata.gz: 6d37a7cc610900148814b0eda41e4d5d1d12ee6eeacba3bddeaa947d7793992b4983b893aa2a1b22cf8641fc2a8954384f52bc92aa5db2a45ef1aa8d3938f63d
-  data.tar.gz: 8d6ba4e24d856e9498f2bea63a9570d9b04439ad9efb84913c43bd575a1a19a442282f87a40a6244e4386869aab85bb836a6e5eea5abae476017a4f69aba7456
+  metadata.gz: f2ae0819199d9c5ef9d0e221f3a743612fb18c1b392922788c9741eb6ed0172c2ba9aeef566d408b30bfd4a19df2a468edf98cef025923c70e0e2a30fb17d39c
+  data.tar.gz: e958a7d97360166bf852d8cb69b294b452176b0f981537df80478e1c5daaa817964a3d877746307d86d0018dc808ec89d58635eee594a7180c5af7a8b6070ba2

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 1.1.2
+
+## Fixed
+* Bug with inheritance and mixins ([@nesaulov][]) [#93](https://github.com/nesaulov/surrealist/pull/93)
+
 # 1.1.1
 
 ## Fixed

data/Gemfile

@@ -7,6 +7,7 @@ group :development, :test do
   gem 'active_model_serializers', '~> 0.10.0'
   gem 'activerecord'
   gem 'benchmark-ips'
+  gem 'blueprinter'
   gem 'coveralls', require: false
   gem 'dry-struct'
   gem 'dry-types'

data/benchmarks/surrealist_vs_ams.rb

@@ -1,8 +1,10 @@
+# rubocop:disable Metrics/AbcSize,Metrics/MethodLength
 require_relative '../lib/surrealist'
 require 'benchmark/ips'
 require 'active_record'
 require 'active_model'
 require 'active_model_serializers'
+require 'blueprinter'
 
 ActiveRecord::Base.establish_connection(
   adapter:  'sqlite3',
@@ -25,7 +27,7 @@ ActiveRecord::Schema.define do
   create_table :books do |table|
     table.column :title, :string
     table.column :year, :string
-    table.belongs_to :author
+    table.belongs_to :author, foreign_key: true
   end
 end
 
@@ -49,11 +51,23 @@ class UserSurrealistSerializer < Surrealist::Serializer
   json_schema { { name: String, email: String } }
 end
 
+class UserAMSSerializer < ActiveModel::Serializer
+  attributes :name, :email
+end
+
+class UserBlueprint < Blueprinter::Base
+  fields :name, :email
+end
+
 ### Associations ###
 
 class AuthorSurrealistSerializer < Surrealist::Serializer
   json_schema do
-    { name: String, last_name: String, full_name: String, age: Integer, books: Object }
+    { name: String, last_name: String, full_name: String, age: Integer, books: Array }
+  end
+
+  def books
+    object.books.to_a
   end
 
   def full_name
@@ -65,125 +79,159 @@ class BookSurrealistSerializer < Surrealist::Serializer
   json_schema { { title: String, year: String } }
 end
 
+class BookAMSSerializer < ActiveModel::Serializer
+  attributes :title, :year
+end
+
+class BookBlueprint < Blueprinter::Base
+  fields :title, :year
+end
+
+class AuthorAMSSerializer < ActiveModel::Serializer
+  attributes :name, :last_name, :full_name, :age
+  has_many :books, serializer: BookAMSSerializer
+end
+
+class AuthorBlueprint < Blueprinter::Base
+  fields :name, :last_name, :age
+  field :full_name do |author|
+    "#{author.name} #{author.last_name}"
+  end
+  association :books, blueprint: BookBlueprint
+end
+
 class Author < ActiveRecord::Base
   include Surrealist
   surrealize_with AuthorSurrealistSerializer
 
   has_many :books
+
+  def full_name
+    "#{name} #{last_name}"
+  end
 end
 
 class Book < ActiveRecord::Base
   include Surrealist
   surrealize_with BookSurrealistSerializer
 
-  belongs_to :author
+  belongs_to :author, required: true
 end
 
-class AuthorSerializer < ActiveModel::Serializer
-  attributes :name, :last_name, :age
+N = 3000
+N.times { User.create!(name: random_name, email: "#{random_name}@test.com") }
+(N / 2).times { Author.create!(name: random_name, last_name: random_name, age: rand(80)) }
+N.times { Book.create!(title: random_name, year: "19#{rand(10..99)}", author_id: rand(1..N / 2)) }
 
-  attribute :full_name do
-    "#{object.name} #{object.last_name}"
+def sort(obj)
+  case obj
+  when Array then obj.map { |el| sort(el) }
+  when Hash then obj.transform_values { |v| sort(v) }
+  else obj
   end
-
-  has_many :books
 end
 
-class BookSerializer < ActiveModel::Serializer
-  attributes :title, :year
+def check_correctness(serializers)
+  results = serializers.map(&:call).map { |r| sort(JSON.parse(r)) }
+  raise 'Results are not the same' if results.uniq.size > 1
 end
 
-N = 3000
-N.times { User.create!(name: random_name, email: "#{random_name}@test.com") }
-(N / 2).times { Author.create!(name: random_name, last_name: random_name, age: rand(80)) }
-N.times { Book.create!(title: random_name, year: "19#{rand(10..99)}", author_id: rand(1..N)) }
-
-def benchmark_instance(ams_arg = '')
-  user = User.find(rand(1..N))
+def benchmark(names, serializers)
+  check_correctness(serializers)
 
   Benchmark.ips do |x|
     x.config(time: 5, warmup: 2)
 
-    x.report("AMS#{ams_arg}: instance") do
-      ActiveModelSerializers::SerializableResource.new(user).to_json
-    end
-
-    x.report('Surrealist: instance through .surrealize') do
-      user.surrealize
-    end
-
-    x.report('Surrealist: instance through Surrealist::Serializer') do
-      UserSurrealistSerializer.new(user).surrealize
-    end
+    names.zip(serializers).each { |name, proc| x.report(name, &proc) }
 
     x.compare!
   end
 end
 
-def benchmark_collection(ams_arg = '')
-  users = User.all
+def benchmark_instance(ams_arg: '', oj_arg: '')
+  user = User.find(rand(1..N))
 
-  Benchmark.ips do |x|
-    x.config(time: 5, warmup: 2)
+  names = ["AMS#{[ams_arg, oj_arg].join(' ')}: instance",
+           'Surrealist: instance through .surrealize',
+           'Surrealist: instance through Surrealist::Serializer',
+           "ActiveModel::Serializers::JSON#{oj_arg} instance",
+           "Blueprinter#{oj_arg}"]
 
-    x.report("AMS#{ams_arg}: collection") do
-      ActiveModelSerializers::SerializableResource.new(users).to_json
-    end
+  serializers = [-> { UserAMSSerializer.new(user).to_json },
+                 -> { user.surrealize },
+                 -> { UserSurrealistSerializer.new(user).surrealize },
+                 -> { user.to_json(only: %i[name email]) },
+                 -> { UserBlueprint.render(user) }]
 
-    x.report('Surrealist: collection through Surrealist.surrealize_collection()') do
-      Surrealist.surrealize_collection(users)
-    end
+  benchmark(names, serializers)
+end
 
-    x.report('Surrealist: collection through Surrealist::Serializer') do
-      UserSurrealistSerializer.new(users).surrealize
-    end
+def benchmark_collection(ams_arg: '', oj_arg: '')
+  users = User.all
 
-    x.compare!
-  end
+  names = ["AMS#{[ams_arg, oj_arg].join(' ')}: collection",
+           'Surrealist: collection through Surrealist.surrealize_collection()',
+           'Surrealist: collection through Surrealist::Serializer',
+           "ActiveModel::Serializers::JSON#{oj_arg} collection",
+           "Blueprinter collection#{oj_arg}"]
+
+  serializers = [lambda do
+                   ActiveModel::Serializer::CollectionSerializer.new(
+                     users, root: nil, serializer: UserAMSSerializer
+                   ).to_json
+                 end,
+                 -> { Surrealist.surrealize_collection(users) },
+                 -> { UserSurrealistSerializer.new(users).surrealize },
+                 -> { users.to_json(only: %i[name email]) },
+                 -> { UserBlueprint.render(users) }]
+
+  benchmark(names, serializers)
 end
 
 def benchmark_associations_instance
   instance = Author.find(rand((1..(N / 2))))
 
-  Benchmark.ips do |x|
-    x.config(time: 5, warmup: 2)
-
-    x.report('AMS (associations): instance') do
-      ActiveModelSerializers::SerializableResource.new(instance).to_json
-    end
-
-    x.report('Surrealist (associations): instance through .surrealize') do
-      instance.surrealize
-    end
-
-    x.report('Surrealist (associations): instance through Surrealist::Serializer') do
-      AuthorSurrealistSerializer.new(instance).surrealize
-    end
-
-    x.compare!
-  end
+  names = ['AMS (associations): instance',
+           'Surrealist (associations): instance through .surrealize',
+           'Surrealist (associations): instance through Surrealist::Serializer',
+           'ActiveModel::Serializers::JSON (associations)',
+           'Blueprinter (associations)']
+
+  serializers = [-> { AuthorAMSSerializer.new(instance).to_json },
+                 -> { instance.surrealize },
+                 -> { AuthorSurrealistSerializer.new(instance).surrealize },
+                 lambda do
+                   instance.to_json(only: %i[name last_name age], methods: %i[full_name],
+                                    include: { books: { only: %i[title year] } })
+                 end,
+                 -> { AuthorBlueprint.render(instance) }]
+
+  benchmark(names, serializers)
 end
 
 def benchmark_associations_collection
   collection = Author.all
 
-  Benchmark.ips do |x|
-    x.config(time: 5, warmup: 2)
-
-    x.report('AMS (associations): collection') do
-      ActiveModelSerializers::SerializableResource.new(collection).to_json
-    end
-
-    x.report('Surrealist (associations): collection through Surrealist.surrealize_collection()') do
-      Surrealist.surrealize_collection(collection)
-    end
-
-    x.report('Surrealist (associations): collection through Surrealist::Serializer') do
-      AuthorSurrealistSerializer.new(collection).surrealize
-    end
-
-    x.compare!
-  end
+  names = ['AMS (associations): collection',
+           'Surrealist (associations): collection through Surrealist.surrealize_collection()',
+           'Surrealist (associations): collection through Surrealist::Serializer',
+           'ActiveModel::Serializers::JSON (associations): collection',
+           'Blueprinter (associations): collection']
+
+  serializers = [lambda do
+                   ActiveModel::Serializer::CollectionSerializer.new(
+                     collection, root: nil, serializer: AuthorAMSSerializer
+                   ).to_json
+                 end,
+                 -> { Surrealist.surrealize_collection(collection) },
+                 -> { AuthorSurrealistSerializer.new(collection).surrealize },
+                 lambda do
+                   collection.to_json(only: %i[name last_name age], methods: %i[full_name],
+                                      include: { books: { only: %i[title year] } })
+                 end,
+                 -> { AuthorBlueprint.render(collection) }]
+
+  benchmark(names, serializers)
 end
 
 # Default configuration
@@ -194,8 +242,21 @@ benchmark_collection
 puts "\n------- Turning off AMS logger -------\n"
 ActiveModelSerializers.logger.level = Logger::Severity::UNKNOWN
 
-benchmark_instance('(without logging)')
-benchmark_collection('(without logging)')
+benchmark_instance(ams_arg: '(without logging)')
+benchmark_collection(ams_arg: '(without logging)')
+
+# Associations
+benchmark_associations_instance
+benchmark_associations_collection
+
+puts "\n------- Enabling Oj.optimize_rails() & Blueprinter config.generator = Oj -------\n"
+Oj.optimize_rails
+Blueprinter.configure do |config|
+  config.generator = Oj
+end
+
+benchmark_instance(ams_arg: '(without logging)', oj_arg: '(with Oj)')
+benchmark_collection(ams_arg: '(without logging)', oj_arg: '(with Oj)')
 
 # Associations
 benchmark_associations_instance
@@ -241,3 +302,4 @@ benchmark_associations_collection
 #   Surrealist (associations): collection through Surrealist.surrealize_collection():        2.4 i/s
 #   Surrealist (associations): collection through Surrealist::Serializer:        2.4 i/s - 1.03x  slower
 #   AMS (associations): collection:        1.5 i/s - 1.60x  slower
+# rubocop:enable Metrics/AbcSize,Metrics/MethodLength

data/lib/surrealist/schema_definer.rb

@@ -19,42 +19,6 @@ module Surrealist
         raise Surrealist::InvalidSchemaError, SCHEMA_TYPE_ERROR unless hash.is_a?(Hash)
 
         Surrealist::VarsHelper.set_schema(klass, hash)
-        define_missing_methods(klass, hash) if klass < Surrealist::Serializer
-      end
-
-      private
-
-      # Defines all methods from the json_schema on Serializer instance in order to increase
-      # performance (comparing to using method_missing)
-      #
-      # @param [Object] klass class of the object where methods will be defined
-      #
-      # @param [Hash] hash the schema hash
-      def define_missing_methods(klass, hash)
-        methods = find_methods(hash)
-        klass.include(Module.new do
-          instance_exec do
-            methods.each do |method|
-              define_method method do
-                if (object = instance_variable_get('@object'))
-                  object.public_send(method)
-                end
-              end
-            end
-          end
-        end)
-      end
-
-      # Takes out all keys from a hash
-      #
-      # @param [Hash] hash a hash to take keys from
-      #
-      # @return [Array] an array of keys
-      def find_methods(hash)
-        hash.each_with_object([]) do |(k, v), keys|
-          keys.push(k)
-          keys.concat(find_methods(v)) if v.is_a? Hash
-        end
       end
     end
   end

data/lib/surrealist/version.rb

@@ -2,5 +2,5 @@
 
 module Surrealist
   # Defines the version of Surrealist
-  VERSION = '1.1.1'.freeze
+  VERSION = '1.1.2'.freeze
 end

data/lib/surrealist.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'oj'
+require 'set'
 require_relative 'surrealist/any'
 require_relative 'surrealist/bool'
 require_relative 'surrealist/builder'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: surrealist
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Nikita Esaulov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-24 00:00:00.000000000 Z
+date: 2018-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj