surrealist 0.4.0 → 1.0.0

data/benchmarks/surrealist_vs_ams.rb

@@ -0,0 +1,243 @@
+require_relative '../lib/surrealist'
+require 'benchmark/ips'
+require 'active_record'
+require 'active_model'
+require 'active_model_serializers'
+
+ActiveRecord::Base.establish_connection(
+  adapter:  'sqlite3',
+  database: ':memory:',
+)
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define do
+  create_table :users do |table|
+    table.column :name, :string
+    table.column :email, :string
+  end
+
+  create_table :authors do |table|
+    table.column :name, :string
+    table.column :last_name, :string
+    table.column :age, :int
+  end
+
+  create_table :books do |table|
+    table.column :title, :string
+    table.column :year, :string
+    table.belongs_to :author
+  end
+end
+
+ActiveModelSerializers.config.adapter = :json
+
+def random_name
+  ('a'..'z').to_a.shuffle.join('').first(10).capitalize
+end
+
+class User < ActiveRecord::Base
+  include Surrealist
+
+  json_schema { { name: String, email: String } }
+end
+
+class UserSerializer < ActiveModel::Serializer
+  attributes :name, :email
+end
+
+class UserSurrealistSerializer < Surrealist::Serializer
+  json_schema { { name: String, email: String } }
+end
+
+### Associations ###
+
+class AuthorSurrealistSerializer < Surrealist::Serializer
+  json_schema do
+    { name: String, last_name: String, full_name: String, age: Integer, books: Object }
+  end
+
+  def full_name
+    "#{object.name} #{object.last_name}"
+  end
+end
+
+class BookSurrealistSerializer < Surrealist::Serializer
+  json_schema { { title: String, year: String } }
+end
+
+class Author < ActiveRecord::Base
+  include Surrealist
+  surrealize_with AuthorSurrealistSerializer
+
+  has_many :books
+end
+
+class Book < ActiveRecord::Base
+  include Surrealist
+  surrealize_with BookSurrealistSerializer
+
+  belongs_to :author
+end
+
+class AuthorSerializer < ActiveModel::Serializer
+  attributes :name, :last_name, :age
+
+  attribute :full_name do
+    "#{object.name} #{object.last_name}"
+  end
+
+  has_many :books
+end
+
+class BookSerializer < ActiveModel::Serializer
+  attributes :title, :year
+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))
+
+  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
+
+    x.compare!
+  end
+end
+
+def benchmark_collection(ams_arg = '')
+  users = User.all
+
+  Benchmark.ips do |x|
+    x.config(time: 5, warmup: 2)
+
+    x.report("AMS#{ams_arg}: collection") do
+      ActiveModelSerializers::SerializableResource.new(users).to_json
+    end
+
+    x.report('Surrealist: collection through Surrealist.surrealize_collection()') do
+      Surrealist.surrealize_collection(users)
+    end
+
+    x.report('Surrealist: collection through Surrealist::Serializer') do
+      UserSurrealistSerializer.new(users).surrealize
+    end
+
+    x.compare!
+  end
+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
+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
+end
+
+# Default configuration
+benchmark_instance
+benchmark_collection
+
+# With AMS logger turned off
+puts "\n------- Turning off AMS logger -------\n"
+ActiveModelSerializers.logger.level = Logger::Severity::UNKNOWN
+
+benchmark_instance('(without logging)')
+benchmark_collection('(without logging)')
+
+# Associations
+benchmark_associations_instance
+benchmark_associations_collection
+
+# ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-darwin16]
+# -- Instance --
+# Comparison:
+#   Surrealist: instance through .surrealize:    39599.6 i/s
+#   Surrealist: instance through Surrealist::Serializer:    36452.5 i/s - same-ish: difference falls within error
+#   AMS: instance:     1938.9 i/s - 20.42x  slower
+#
+# -- Collection --
+# Comparison:
+#   Surrealist: collection through Surrealist.surrealize_collection():       15.0 i/s
+#   Surrealist: collection through Surrealist::Serializer:       12.8 i/s - 1.17x  slower
+#   AMS: collection:        6.1 i/s - 2.44x  slower
+#
+# --- Without AMS logging (which is turned on by default) ---
+#
+# -- Instance --
+# Comparison:
+#   Surrealist: instance through .surrealize:    40401.4 i/s
+#   Surrealist: instance through Surrealist::Serializer:    29488.3 i/s - 1.37x  slower
+#   AMS(without logging): instance:     4571.7 i/s - 8.84x  slower
+#
+# -- Collection --
+# Comparison:
+#   Surrealist: collection through Surrealist.surrealize_collection():       15.2 i/s
+#   Surrealist: collection through Surrealist::Serializer:       12.0 i/s - 1.27x  slower
+#   AMS(without logging): collection:        6.1 i/s - 2.50x  slower
+#
+# --- Associations ---
+#
+# -- Instance --
+# Comparison:
+#   Surrealist (associations): instance through Surrealist::Serializer:     4016.3 i/s
+#   Surrealist (associations): instance through .surrealize:     4004.6 i/s - same-ish: difference falls within error
+#   AMS (associations): instance:     1303.0 i/s - 3.08x  slower
+#
+# -- Collection --
+# Comparison:
+#   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

data/lib/surrealist/builder.rb

@@ -9,7 +9,7 @@ module Surrealist
     # @param [Carrier] carrier instance of Surrealist::Carrier
     # @param [Hash] schema the schema defined in the object's class.
     # @param [Object] instance the instance of the object which methods from the schema are called on.
-    def initialize(carrier:, schema:, instance:)
+    def initialize(carrier, schema, instance)
       @carrier = carrier
       @schema = schema
       @instance = instance
@@ -24,13 +24,13 @@ module Surrealist
     #   does not have a corresponding method on the object.
     #
     # @return [Hash] a hash that will be dumped into JSON.
-    def call(schema: @schema, instance: @instance)
+    def call(schema = @schema, instance = @instance)
       schema.each do |schema_key, schema_value|
         if schema_value.is_a?(Hash)
           check_for_ar(schema, instance, schema_key, schema_value)
         else
-          ValueAssigner.assign(schema: Schema.new(schema_key, schema_value),
-                               instance: instance) { |coerced_value| schema[schema_key] = coerced_value }
+          ValueAssigner.assign(Schema.new(schema_key, schema_value),
+                               instance) { |coerced_value| schema[schema_key] = coerced_value }
         end
       end
     rescue NoMethodError => e
@@ -53,8 +53,7 @@ module Surrealist
       if ar_collection?(instance, key)
         construct_collection(schema, instance, key, value)
       else
-        call(schema:   value,
-             instance: instance.respond_to?(key) ? instance.send(key) : instance)
+        call(value, instance.respond_to?(key) ? instance.send(key) : instance)
       end
     end
 
@@ -81,11 +80,8 @@ module Surrealist
     # @return [Hash] the schema hash
     def construct_collection(schema, instance, key, value)
       schema[key] = []
-      instance.send(key).each do |i|
-        schema[key] << call(
-          schema:   Copier.deep_copy(hash: value, carrier: carrier),
-          instance: i,
-        )
+      instance.send(key).each do |inst|
+        schema[key].push(call(Copier.deep_copy(value, carrier), inst))
       end
     end
   end

data/lib/surrealist/carrier.rb

@@ -43,6 +43,10 @@ module Surrealist
       self
     end
 
+    def no_args_provided?
+      @no_args ||= no_args
+    end
+
     private
 
     # Checks all boolean arguments
@@ -63,11 +67,7 @@ module Surrealist
     # Checks if +namespaces_nesting_level+ is a positive integer
     # @raise ArgumentError
     def check_namespaces_nesting!
-      unless namespaces_nesting_level.is_a?(Integer)
-        Surrealist::ExceptionRaiser.raise_invalid_nesting!(namespaces_nesting_level)
-      end
-
-      if namespaces_nesting_level <= 0
+      if !namespaces_nesting_level.is_a?(Integer) || namespaces_nesting_level <= 0
         Surrealist::ExceptionRaiser.raise_invalid_nesting!(namespaces_nesting_level)
       end
     end
@@ -84,5 +84,10 @@ module Surrealist
     def strip_root!
       root.is_a?(String) && @root = root.strip
     end
+
+    def no_args
+      !camelize && !include_root && !include_namespaces && root.nil? &&
+        namespaces_nesting_level == DEFAULT_NESTING_LEVEL
+    end
   end
 end

data/lib/surrealist/class_methods.rb

@@ -98,9 +98,9 @@ module Surrealist
     # @param [Class] klass a class that should inherit form Surrealist::Serializer
     #
     # @raise ArgumentError if Surrealist::Serializer is not found in the ancestors chain
-    def surrealize_with(klass)
+    def surrealize_with(klass, tag: Surrealist::VarsHelper::DEFAULT_TAG)
       if klass < Surrealist::Serializer
-        Surrealist::VarsHelper.set_serializer(self, klass)
+        Surrealist::VarsHelper.add_serializer(self, klass, tag: tag)
       else
         raise ArgumentError, "#{klass} should be inherited from Surrealist::Serializer"
       end

data/lib/surrealist/copier.rb

@@ -13,7 +13,7 @@ module Surrealist
       # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
       #
       # @return [Hash] a copied hash.
-      def deep_copy(hash:, klass: false, carrier:)
+      def deep_copy(hash, carrier, klass = false)
         namespaces_condition = carrier.include_namespaces || carrier.namespaces_nesting_level != DEFAULT_NESTING_LEVEL # rubocop:disable Metrics/LineLength
 
         if !klass && (carrier.include_root || namespaces_condition)
@@ -34,13 +34,15 @@ module Surrealist
       #
       # @return [Hash] deeply copied hash, possibly wrapped.
       def copied_and_possibly_wrapped_hash(hash, klass, carrier, namespaces_condition)
+        return copy_hash(hash) if carrier.no_args_provided?
+
         if carrier.root
-          wrap_schema_into_root(schema: hash, carrier: carrier, root: carrier.root.to_s)
+          wrap_schema_into_root(hash, carrier, carrier.root.to_s)
         elsif namespaces_condition
-          wrap_schema_into_namespace(schema: hash, klass: klass, carrier: carrier)
+          wrap_schema_into_namespace(hash, carrier, klass)
         elsif carrier.include_root
           actual_class = Surrealist::StringUtils.extract_class(klass)
-          wrap_schema_into_root(schema: hash, carrier: carrier, root: actual_class)
+          wrap_schema_into_root(hash, carrier, actual_class)
         else
           copy_hash(hash)
         end
@@ -52,7 +54,7 @@ module Surrealist
       # @param [Hash] wrapper the wrapper of the resulting hash.
       #
       # @return [Hash] deeply copied hash.
-      def copy_hash(hash, wrapper: {})
+      def copy_hash(hash, wrapper = {})
         hash.each_with_object(wrapper) do |(key, value), new|
           new[key] = value.is_a?(Hash) ? copy_hash(value) : value
         end
@@ -65,14 +67,14 @@ module Surrealist
       # @param [String] root what the schema will be wrapped into
       #
       # @return [Hash] a hash with schema wrapped inside a root key.
-      def wrap_schema_into_root(schema:, carrier:, root:)
+      def wrap_schema_into_root(schema, carrier, root)
         root_key = if carrier.camelize
                      Surrealist::StringUtils.camelize(root, false).to_sym
                    else
                      Surrealist::StringUtils.underscore(root).to_sym
                    end
         result = Hash[root_key => {}]
-        copy_hash(schema, wrapper: result[root_key])
+        copy_hash(schema, result[root_key])
 
         result
       end
@@ -84,11 +86,9 @@ module Surrealist
       # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
       #
       # @return [Hash] nested hash (see +inject_schema+)
-      def wrap_schema_into_namespace(schema:, klass:, carrier:)
+      def wrap_schema_into_namespace(schema, carrier, klass)
         nested_hash = Surrealist::StringUtils.break_namespaces(
-          klass,
-          camelize: carrier.camelize,
-          nesting_level: carrier.namespaces_nesting_level,
+          klass, carrier.camelize, carrier.namespaces_nesting_level
         )
 
         inject_schema(nested_hash, copy_hash(schema))

data/lib/surrealist/exception_raiser.rb

@@ -25,6 +25,9 @@ module Surrealist
   # Error class for cases where +namespaces_nesting_level+ is set to 0.
   class InvalidNestingLevel < ArgumentError; end
 
+  # Error class for unknown tag passed
+  class UnknownTagError < ArgumentError; end
+
   # A class that raises all Surrealist exceptions
   module ExceptionRaiser
     CLASS_NAME_NOT_PASSED           = "Can't wrap schema in root key - class name was not passed".freeze
@@ -89,6 +92,16 @@ module Surrealist
               "#{e.message}. You have probably defined a key " \
               "in the schema that doesn't have a corresponding method."
       end
+
+      # Raises ArgumentError if a tag has no corresponding serializer
+      #
+      # @param [String] tag Wrong tag
+      #
+      # @raise Surrealist::UnknownTagError
+      def raise_unknown_tag!(tag)
+        raise Surrealist::UnknownTagError,
+              "The tag specified (#{tag}) has no corresponding serializer"
+      end
     end
   end
 end

data/lib/surrealist/instance_methods.rb

@@ -49,16 +49,30 @@ module Surrealist
     #   # => "{\"name\":\"Nikita\",\"age\":23}"
     #   # For more examples see README
     def surrealize(**args)
-      if (serializer = Surrealist::VarsHelper.find_serializer(self.class))
+      return args[:serializer].new(self).surrealize(args) if args[:serializer]
+
+      if (serializer = find_serializer(args[:for]))
         return serializer.new(self).surrealize(args)
       end
 
-      JSON.dump(build_schema(args))
+      Oj.dump(Surrealist.build_schema(instance: self, **args), mode: :compat)
     end
 
     # Invokes +Surrealist+'s class method +build_schema+
     def build_schema(**args)
+      return args[:serializer].new(self).build_schema(args) if args[:serializer]
+
+      if (serializer = find_serializer(args[:for]))
+        return serializer.new(self).build_schema(args)
+      end
+
       Surrealist.build_schema(instance: self, **args)
     end
+
+    private
+
+    def find_serializer(tag)
+      Surrealist::VarsHelper.find_serializer(self.class, tag: tag)
+    end
   end
 end

data/lib/surrealist/schema_definer.rb

@@ -4,19 +4,58 @@ module Surrealist
   # A class that defines a method on the object that stores the schema.
   module SchemaDefiner
     SCHEMA_TYPE_ERROR = 'Schema should be defined as a hash'.freeze
-    # Defines an instance variable on the object that stores the schema.
-    #
-    # @param [Object] klass class of the object that needs to be surrealized.
-    #
-    # @param [Hash] hash the schema defined in the object's class.
-    #
-    # @return [Hash] +@__surrealist_schema+ variable that stores the schema of the object.
-    #
-    # @raise +Surrealist::InvalidSchemaError+ if schema was defined not through a hash.
-    def self.call(klass, hash)
-      raise Surrealist::InvalidSchemaError, SCHEMA_TYPE_ERROR unless hash.is_a?(Hash)
 
-      Surrealist::VarsHelper.set_schema(klass, hash)
+    class << self
+      # Defines an instance variable on the object that stores the schema.
+      #
+      # @param [Object] klass class of the object that needs to be surrealized.
+      #
+      # @param [Hash] hash the schema defined in the object's class.
+      #
+      # @return [Hash] +@__surrealist_schema+ variable that stores the schema of the object.
+      #
+      # @raise +Surrealist::InvalidSchemaError+ if schema was defined not through a hash.
+      def call(klass, hash)
+        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
 end

data/lib/surrealist/serializer.rb

@@ -50,13 +50,22 @@ module Surrealist
 
     # Passes build_schema to Surrealist
     def build_schema(**args)
-      Surrealist.build_schema(instance: self, **args)
+      if object.respond_to?(:each)
+        build_collection_schema(args)
+      else
+        Surrealist.build_schema(instance: self, **args)
+      end
     end
 
     private
 
     attr_reader :object, :context
 
+    # Maps collection and builds schema for each instance.
+    def build_collection_schema(**args)
+      object.map { |object| self.class.new(object, context).build_schema(args) }
+    end
+
     # Methods not found inside serializer will be invoked on the object
     def method_missing(method, *args, &block)
       object.public_send(method, *args, &block)

data/lib/surrealist/string_utils.rb

@@ -37,7 +37,7 @@ module Surrealist
           snake_string.to_s.gsub(UNDERSCORE_REGEXP) { Regexp.last_match[1].capitalize }
         else
           parts = snake_string.split(UNDERSCORE, 2)
-          parts[0] << camelize(parts[1]) if parts.size > 1
+          parts[0].concat(camelize(parts[1])) if parts.size > 1
           parts[0] || EMPTY_STRING
         end
       end
@@ -68,7 +68,7 @@ module Surrealist
       # @raise Surrealist::InvalidNestingLevel if nesting level is specified as 0.
       #
       # @return [Hash] a nested hash.
-      def break_namespaces(klass, camelize:, nesting_level:)
+      def break_namespaces(klass, camelize, nesting_level)
         Surrealist::ExceptionRaiser.raise_invalid_nesting!(nesting_level) unless nesting_level > 0
 
         klass.split(NAMESPACES_SEPARATOR).last(nesting_level).reverse.inject({}) do |a, n|

data/lib/surrealist/type_helper.rb

@@ -4,7 +4,7 @@ module Surrealist
   # Service class for type checking
   module TypeHelper
     # Dry-types class matcher
-    DRY_TYPE_CLASS = 'Dry::Types'.freeze
+    DRY_TYPE_CLASS = /Dry::Types/
 
     class << self
       # Checks if value returned from a method is an instance of type class specified
@@ -14,12 +14,12 @@ module Surrealist
       # @param [Class] type class representing data type.
       #
       # @return [boolean]
-      def valid_type?(value:, type:)
+      def valid_type?(value, type)
         return true if type == Any
 
         if type == Bool
           Surrealist::Carrier::BOOLEANS.include?(value)
-        elsif dry_type?(type)
+        elsif defined?(Dry::Types) && dry_type?(type)
           type.try(value).success?
         else
           value.nil? || value.is_a?(type)
@@ -32,7 +32,7 @@ module Surrealist
       # @param [Class] type class representing data type
       #
       # @return [any] coerced value
-      def coerce(value:, type:)
+      def coerce(value, type)
         return value unless dry_type?(type)
         return value if type.try(value).input == value
 
@@ -50,7 +50,7 @@ module Surrealist
         if type.respond_to?(:primitive) || type.class.name.nil?
           true
         else
-          type.class.name.match(DRY_TYPE_CLASS)
+          type.class.name =~ DRY_TYPE_CLASS
         end
       end
     end