surrealist 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddb587c43e017b7be30cbcddf5ae8ee32094cff322233dbd89ed32c6bd8d5f7f
-  data.tar.gz: 9ac93b85f00189ff0937e056ac1475243e9364a78c70d5c570583028f4073f93
+  metadata.gz: 936bf35d7c1f0511db6d2f9458ade02330ec2246d444f9c0c7f9069ed7f24d73
+  data.tar.gz: 1b91381b04081fb2e4cd6af4167cd41907f982c9a1f713077e76d78ec51a82c4
 SHA512:
-  metadata.gz: 6ad65631c97a6ab8b77d678fac704d8da83ab0d1f7ca1b263169a643ca0e4fe33aaec846bbecd1504ba28147c83fc878b60232acec75cbb11195d6310ebb0a5a
-  data.tar.gz: 1c2a5350fd1d780dad01df6e5f60f01155c356f319f85e8f623bcb5e87b6bf75cdcc31b6604e309f1a5367d9cceb3279448c85eeea452a4818e27f55adbc5966
+  metadata.gz: d058ddf6a4314ee51c09fc2bd7866302971d9a8f9171430189d95df37871331883237519579c9044a4e720435bdf99702e134e9af992cddb4b5a241db528a92e
+  data.tar.gz: ccee664c6cadf85ec84e5584a8ac1c9490f43a5dfb7308ecf7d8d883daa5f4bbc6c6f1a2836c58f30677bb1ca6a5cfb1c5111f03db9ca6e0b9fade5420a11998

data/.rubocop.yml

@@ -141,3 +141,6 @@ Style/TrailingCommaInArguments:
 
 Style/TrailingCommaInLiteral:
   EnforcedStyleForMultiline: comma
+
+Style/MethodMissing:
+  Enabled: false

data/.travis.yml

@@ -8,6 +8,8 @@ matrix:
   include:
     - rvm: ruby-head
       gemfile: Gemfile
+    - rvm: 2.5.0
+      gemfile: Gemfile
     - rvm: 2.4.2
       gemfile: Gemfile
     - rvm: 2.4.0
@@ -17,6 +19,6 @@ matrix:
     - rvm: 2.3.1
       gemfile: Gemfile
     - rvm: 2.2.5
-      gemfile: Gemfile
+      gemfile: gemfiles/activerecord42.gemfile
     - rvm: 2.2.0
       gemfile: gemfiles/activerecord42.gemfile

data/CHANGELOG.md

@@ -1,8 +1,20 @@
+# 0.4.0
+
+## Added
+* Introduce an abstract serializer class (@nesaulov) #61
+* Full integration for Sequel (@nesaulov) #47
+* Integration for ROM 4.x (@nesaulov) #56
+* Ruby 2.5 support (@nesaulov) #57
+
+## Miscellaneous
+* Memory & performance optimizations (@nesaulov) #51
+* Refactorings (@nulldef) #55
+
 # 0.3.0
 
 ## Added
 * Full integration for ActiveRecord (@nesaulov, @AlessandroMinali) #37
-* Full integration for ROM (@nesaulov, @AlessandroMinali) #37
+* Full integration for ROM <= 3 (@nesaulov, @AlessandroMinali) #37
 * `root` optional argument (@chrisatanasian) #32
 * Nested records surrealization (@AlessandroMinali) #34
 

data/Gemfile

@@ -6,11 +6,9 @@ gemspec
 group :development, :test do
   gem 'activerecord'
   gem 'coveralls', require: false
-  gem 'data_mapper'
-  gem 'dm-sqlite-adapter'
   gem 'dry-struct'
   gem 'dry-types'
-  gem 'rom', '~> 3.0'
+  gem 'rom', '~> 4.0'
   gem 'rom-repository'
   gem 'rom-sql'
   gem 'sequel'

data/README.md

@@ -24,6 +24,7 @@ to serialize nested objects and structures. [Introductory blogpost.](https://med
   * [Nested objects](#nested-objects)
   * [Delegating Surrealization](#delegating-surrealization)
   * [Usage with Dry::Types](#usage-with-drytypes)
+  * [Defining custom serializers](#defining-custom-serializers)
   * [Build schema](#build-schema)
   * [Camelization](#camelization)
   * [Include root](#include-root)
@@ -247,6 +248,72 @@ Car.new.surrealize
 # => '{ "age": 7, "brand": "Toyota", "doors": null, "horsepower": 140, "fuel_system": "Direct injection", "previous_owner": "John Doe" }'
 ```
 
+### Defining custom serializers
+If you need to keep serialization logic separately from the model, you can define a class that
+will inherit from `Surrealist::Serializer`. To point to that class from the model use a class method
+`.surrealize_with`. Example usage:
+``` ruby
+class CatSerializer < Surrealist::Serializer
+  json_schema { { age: Integer, age_group: String } }
+ 
+  def age_group
+    age <= 5 ? 'kitten' : 'cat'
+  end
+end
+ 
+class Cat
+  include Surrealist
+  attr_reader :age
+ 
+  surrealize_with CatSerializer
+ 
+  def initialize(age)
+    @age = age
+  end
+end
+ 
+Cat.new(12).surrealize # Implicit usage through .surrealize_with
+# => '{ "age": 12, "age_group": "cat" }'
+ 
+CatSerializer.new(Cat.new(3)).surrealize # explicit usage of CatSerializer
+# => '{ "age": 3, "age_group": "kitten" }'
+```
+The constructor of `Surrealist::Serializer` takes two arguments: serializable model (or collection) and 
+a context hash. So if there is an object that is not coupled to serializable model
+but it is still necessary for constructing JSON, you can pass it to constructor as a hash. It will 
+be available in the serializer in the `context` hash. 
+``` ruby
+class IncomeSerializer < Surrealist::Serializer
+  json_schema { { amount: Integer } }
+  
+  def amount
+    current_user.guest? ? 100000000 : object.amount
+  end
+  
+  def current_user
+    context[:current_user]
+  end
+end
+ 
+class Income
+  include Surrealist
+  surrealize_with IncomeSerializer
+   
+  attr_reader :amount
+   
+  def initialize(amount)
+    @amount = amount
+  end  
+end
+ 
+income = Income.new(200)
+IncomeSerializer.new(income, current_user: GuestUser.new).surrealize
+# => '{ "amount": 100000000 }'
+ 
+IncomeSerializer.new(income, current_user: User.find(3)).surrealize
+# => '{ "amount": 200 }'
+```
+
 ### Build schema
 If you don't need to dump the hash to json, you can use `#build_schema`
 method on the instance. It calculates values and checks types, but returns
@@ -451,7 +518,7 @@ type check will be passed. If you want to be strict about `nil`s consider using
 
 ## Roadmap
 Here is a list of features that are not implemented yet (contributions are welcome):
-* [Collection serialization](https://github.com/nesaulov/surrealist/issues/12)
+* [Benchmarks](https://github.com/nesaulov/surrealist/issues/40)
 
 ## Contributing
 Bug reports and pull requests are welcome on GitHub at https://github.com/nesaulov/surrealist.

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
+require_relative '../lib/surrealist'
 require 'bundler/setup'
-require 'surrealist'
 require 'pry'
 
 Pry.start

data/gemfiles/activerecord42.gemfile

@@ -5,8 +5,6 @@ source 'https://rubygems.org'
 group :development, :test do
   gem 'activerecord', '~> 4.2'
   gem 'coveralls', require: false
-  gem 'data_mapper'
-  gem 'dm-sqlite-adapter'
   gem 'dry-struct'
   gem 'dry-types'
   gem 'rom', '~> 3.0'

data/lib/surrealist/builder.rb

@@ -6,8 +6,6 @@ module Surrealist
     # Struct to carry schema along
     Schema = Struct.new(:key, :value).freeze
 
-    attr_reader :carrier, :instance, :schema
-
     # @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.
@@ -31,7 +29,7 @@ module Surrealist
         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),
+          ValueAssigner.assign(schema: Schema.new(schema_key, schema_value),
                                instance: instance) { |coerced_value| schema[schema_key] = coerced_value }
         end
       end
@@ -41,6 +39,8 @@ module Surrealist
 
     private
 
+    attr_reader :carrier, :instance, :schema
+
     # Checks if result is an instance of ActiveRecord::Relation
     #
     # @param [Hash] schema the schema defined in the object's class.

data/lib/surrealist/carrier.rb

@@ -3,6 +3,10 @@
 module Surrealist
   # A data structure to carry arguments across methods.
   class Carrier
+    BOOLEANS = [true, false].freeze
+
+    attr_reader :camelize, :include_root, :include_namespaces, :root, :namespaces_nesting_level
+
     # Public wrapper for Carrier.
     #
     # @param [Boolean] camelize optional argument for converting hash to camelBack.
@@ -16,18 +20,16 @@ module Surrealist
     # @raise ArgumentError if types of arguments are wrong.
     #
     # @return [Carrier] self if type checks were passed.
-    def self.call(camelize:, include_root:, include_namespaces:, root:, namespaces_nesting_level:)
-      new(camelize, include_root, include_namespaces, root, namespaces_nesting_level).sanitize!
+    def self.call(**args)
+      new(args).sanitize!
     end
 
-    attr_reader :camelize, :include_root, :include_namespaces, :root, :namespaces_nesting_level
-
-    def initialize(camelize, include_root, include_namespaces, root, namespaces_nesting_level)
-      @camelize                 = camelize
-      @include_root             = include_root
-      @include_namespaces       = include_namespaces
-      @root                     = root
-      @namespaces_nesting_level = namespaces_nesting_level
+    def initialize(**args)
+      @camelize                 = args.delete(:camelize) || false
+      @include_root             = args.delete(:include_root) || false
+      @include_namespaces       = args.delete(:include_namespaces) || false
+      @root                     = args.delete(:root) || nil
+      @namespaces_nesting_level = args.delete(:namespaces_nesting_level) || DEFAULT_NESTING_LEVEL
     end
 
     # Performs type checks
@@ -47,7 +49,7 @@ module Surrealist
     # @raise ArgumentError
     def check_booleans!
       booleans_hash.each do |key, value|
-        unless [true, false].include?(value)
+        unless BOOLEANS.include?(value)
           raise ArgumentError, "Expected `#{key}` to be either true or false, got #{value}"
         end
       end
@@ -73,7 +75,7 @@ module Surrealist
     # Checks if root is not nil, a non-empty string, or symbol
     # @raise ArgumentError
     def check_root!
-      unless root.nil? || (root.is_a?(String) && root.present?) || root.is_a?(Symbol)
+      unless root.nil? || (root.is_a?(String) && !root.strip.empty?) || root.is_a?(Symbol)
         Surrealist::ExceptionRaiser.raise_invalid_root!(root)
       end
     end

data/lib/surrealist/class_methods.rb

@@ -89,7 +89,21 @@ module Surrealist
 
       Surrealist::ExceptionRaiser.raise_invalid_schema_delegation! unless Helper.surrealist?(klass)
 
-      instance_variable_set('@__surrealist_schema_parent', klass)
+      hash = Surrealist::VarsHelper.find_schema(klass)
+      Surrealist::VarsHelper.set_schema(self, hash)
+    end
+
+    # A DSL method for defining a class that holds serialization logic.
+    #
+    # @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)
+      if klass < Surrealist::Serializer
+        Surrealist::VarsHelper.set_serializer(self, klass)
+      else
+        raise ArgumentError, "#{klass} should be inherited from Surrealist::Serializer"
+      end
     end
   end
 end

data/lib/surrealist/copier.rb

@@ -2,7 +2,9 @@
 
 module Surrealist
   # A helper class for deep copying and wrapping hashes.
-  class Copier
+  module Copier
+    EMPTY_HASH = {}.freeze
+
     class << self
       # Deeply copies the schema hash and wraps it if there is a need to.
       #
@@ -107,7 +109,7 @@ module Surrealist
       # @return [Hash] resulting hash.
       def inject_schema(hash, sub_hash)
         hash.each do |k, v|
-          v == {} ? hash[k] = sub_hash : inject_schema(v, sub_hash)
+          v == EMPTY_HASH ? hash[k] = sub_hash : inject_schema(v, sub_hash)
         end
       end
     end

data/lib/surrealist/exception_raiser.rb

@@ -26,14 +26,18 @@ module Surrealist
   class InvalidNestingLevel < ArgumentError; end
 
   # A class that raises all Surrealist exceptions
-  class ExceptionRaiser
+  module ExceptionRaiser
+    CLASS_NAME_NOT_PASSED           = "Can't wrap schema in root key - class name was not passed".freeze
+    MUST_RESPOND_TO_EACH            = "Can't serialize collection - must respond to :each".freeze
+    CLASS_DOESNT_INCLUDE_SURREALIST = 'Class does not include Surrealist'.freeze
+
     class << self
       # Raises Surrealist::InvalidSchemaDelegation if destination of delegation does not
       # include Surrealist.
       #
       # @raise Surrealist::InvalidSchemaDelegation
       def raise_invalid_schema_delegation!
-        raise Surrealist::InvalidSchemaDelegation, 'Class does not include Surrealist'
+        raise Surrealist::InvalidSchemaDelegation, CLASS_DOESNT_INCLUDE_SURREALIST
       end
 
       # Raises Surrealist::UnknownSchemaError
@@ -50,14 +54,14 @@ module Surrealist
       #
       # @raise Surrealist::UnknownRootError
       def raise_unknown_root!
-        raise Surrealist::UnknownRootError, "Can't wrap schema in root key - class name was not passed"
+        raise Surrealist::UnknownRootError, CLASS_NAME_NOT_PASSED
       end
 
       # Raises Surrealist::InvalidCollectionError
       #
       # @raise Surrealist::InvalidCollectionError
       def raise_invalid_collection!
-        raise Surrealist::InvalidCollectionError, "Can't serialize collection - must respond to :each"
+        raise Surrealist::InvalidCollectionError, MUST_RESPOND_TO_EACH
       end
 
       # Raises ArgumentError if namespaces_nesting_level is not an integer.

data/lib/surrealist/hash_utils.rb

@@ -2,7 +2,7 @@
 
 module Surrealist
   # A helper class for hashes transformations.
-  class HashUtils
+  module HashUtils
     class << self
       # Converts hash's keys to camelBack keys.
       #

data/lib/surrealist/helper.rb

@@ -2,16 +2,14 @@
 
 module Surrealist
   # A generic helper.
-  class Helper
-    class << self
-      # Determines if the class uses the Surrealist mixin.
-      #
-      # @param [Class] klass a class to be checked.
-      #
-      # @return [Boolean] if Surrealist is included in class.
-      def surrealist?(klass)
-        klass < Surrealist
-      end
+  module Helper
+    # Determines if the class uses the Surrealist mixin.
+    #
+    # @param [Class] klass a class to be checked.
+    #
+    # @return [Boolean] if Surrealist is included in class.
+    def self.surrealist?(klass)
+      klass < Surrealist || klass < Surrealist::Serializer
     end
   end
 end

data/lib/surrealist/instance_methods.rb

@@ -6,13 +6,13 @@ module Surrealist
     # Dumps the object's methods corresponding to the schema
     # provided in the object's class and type-checks the values.
     #
-    # @param [Boolean] camelize optional argument for converting hash to camelBack.
-    # @param [Boolean] include_root optional argument for having the root key of the resulting hash
+    # @param [Boolean] [optional] camelize optional argument for converting hash to camelBack.
+    # @param [Boolean] [optional] include_root optional argument for having the root key of the resulting hash
     #   as instance's class name.
-    # @param [Boolean] include_namespaces optional argument for having root key as a nested hash of
+    # @param [Boolean] [optional] include_namespaces optional argument for having root key as a nested hash of
     #   instance's namespaces. Animal::Cat.new.surrealize -> (animal: { cat: { weight: '3 kilos' } })
-    # @param [String] root optional argument for using a specified root key for the hash
-    # @param [Integer] namespaces_nesting_level level of namespaces nesting.
+    # @param [String] [optional] root optional argument for using a specified root key for the hash
+    # @param [Integer] [optional] namespaces_nesting_level level of namespaces nesting.
     #
     # @return [String] a json-formatted string corresponding to the schema
     #   provided in the object's class. Values will be taken from the return values
@@ -48,29 +48,17 @@ module Surrealist
     #   User.new.surrealize
     #   # => "{\"name\":\"Nikita\",\"age\":23}"
     #   # For more examples see README
-    def surrealize(camelize: false, include_root: false, include_namespaces: false, root: nil, namespaces_nesting_level: DEFAULT_NESTING_LEVEL) # rubocop:disable Metrics/LineLength
-      JSON.dump(
-        build_schema(
-          camelize: camelize,
-          include_root: include_root,
-          include_namespaces: include_namespaces,
-          root: root,
-          namespaces_nesting_level: namespaces_nesting_level,
-        ),
-      )
+    def surrealize(**args)
+      if (serializer = Surrealist::VarsHelper.find_serializer(self.class))
+        return serializer.new(self).surrealize(args)
+      end
+
+      JSON.dump(build_schema(args))
     end
 
     # Invokes +Surrealist+'s class method +build_schema+
-    def build_schema(camelize: false, include_root: false, include_namespaces: false, root: nil, namespaces_nesting_level: DEFAULT_NESTING_LEVEL) # rubocop:disable Metrics/LineLength
-      carrier = Surrealist::Carrier.call(
-        camelize: camelize,
-        include_namespaces: include_namespaces,
-        include_root: include_root,
-        root: root,
-        namespaces_nesting_level: namespaces_nesting_level,
-      )
-
-      Surrealist.build_schema(instance: self, carrier: carrier)
+    def build_schema(**args)
+      Surrealist.build_schema(instance: self, **args)
     end
   end
 end

data/lib/surrealist/schema_definer.rb

@@ -2,7 +2,8 @@
 
 module Surrealist
   # A class that defines a method on the object that stores the schema.
-  class SchemaDefiner
+  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.
@@ -13,13 +14,9 @@ module Surrealist
     #
     # @raise +Surrealist::InvalidSchemaError+ if schema was defined not through a hash.
     def self.call(klass, hash)
-      raise Surrealist::InvalidSchemaError, 'Schema should be defined as a hash' unless hash.is_a?(Hash)
+      raise Surrealist::InvalidSchemaError, SCHEMA_TYPE_ERROR unless hash.is_a?(Hash)
 
-      if klass.name =~ /ROM::Struct/
-        klass.class_variable_set('@@__surrealist_schema', hash)
-      else
-        klass.instance_variable_set('@__surrealist_schema', hash)
-      end
+      Surrealist::VarsHelper.set_schema(klass, hash)
     end
   end
 end

data/lib/surrealist/serializer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Surrealist
+  # Abstract class to be inherited from
+  #
+  # @example Usage
+  #   class CatSerializer < Surrealist::Serializer
+  #     json_schema { { age: Integer, age_group: String } }
+  #
+  #     def age_group
+  #       age <= 5 ? 'kitten' : 'cat'
+  #     end
+  #   end
+  #
+  #   class Cat
+  #     include Surrealist
+  #     attr_reader :age
+  #
+  #     surrealize_with CatSerializer
+  #
+  #     def initialize(age)
+  #       @age = age
+  #     end
+  #   end
+  #
+  #   Cat.new(12).surrealize # Checks for schema in CatSerializer (if .surrealize_with is stated)
+  #   # => '{ "age": 12, "age_group": "cat" }'
+  #
+  #   CatSerializer.new(Cat.new(3)).surrealize # explicit usage of CatSerializer
+  #   # => '{ "age": 3, "age_group": "kitten" }'
+  class Serializer
+    extend Surrealist::ClassMethods
+
+    # NOTE: #context will work only when using serializer explicitly,
+    #   e.g `CatSerializer.new(Cat.new(3), food: CatFood.new)`
+    #   And then food will be available inside serializer via `context[:food]`
+    def initialize(object, **context)
+      @object = object
+      @context = context
+    end
+
+    # Checks whether object is a collection or an instance and serializes it
+    def surrealize(**args)
+      if object.respond_to?(:each)
+        Surrealist.surrealize_collection(object, args.merge(context: context))
+      else
+        Surrealist.surrealize(instance: self, **args)
+      end
+    end
+
+    # Passes build_schema to Surrealist
+    def build_schema(**args)
+      Surrealist.build_schema(instance: self, **args)
+    end
+
+    private
+
+    attr_reader :object, :context
+
+    # Methods not found inside serializer will be invoked on the object
+    def method_missing(method, *args, &block)
+      object.public_send(method, *args, &block)
+    end
+
+    # Methods not found inside serializer will be invoked on the object
+    def respond_to_missing?(method, include_private = false)
+      object.respond_to?(method) || super
+    end
+  end
+end

data/lib/surrealist/string_utils.rb

@@ -2,18 +2,27 @@
 
 module Surrealist
   # A helper class for strings transformations.
-  class StringUtils
+  module StringUtils
+    DASH                  = '-'.freeze
+    UNDERSCORE            = '_'.freeze
+    EMPTY_STRING          = ''.freeze
+    DASH_REGEXP1          = /([A-Z]+)([A-Z][a-z])/o
+    DASH_REGEXP2          = /([a-z\d])([A-Z])/o
+    UNDERSCORE_REGEXP     = /(?:^|_)([^_\s]+)/o
+    NAMESPACES_SEPARATOR  = '::'.freeze
+    UNDERSCORE_SUBSTITUTE = '\1_\2'.freeze
+
     class << self
       # Converts a string to snake_case.
       #
       # @param [String] string a string to be underscored.
       #
-      # @return [String] underscored string.
+      # @return [String] new underscored string.
       def underscore(string)
-        string.gsub('::', '_')
-          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-          .tr('-', '_')
+        string.gsub(NAMESPACES_SEPARATOR, UNDERSCORE)
+          .gsub(DASH_REGEXP1, UNDERSCORE_SUBSTITUTE)
+          .gsub(DASH_REGEXP2, UNDERSCORE_SUBSTITUTE)
+          .tr(DASH, UNDERSCORE)
           .downcase
       end
 
@@ -25,12 +34,11 @@ module Surrealist
       # @return [String] camelized string.
       def camelize(snake_string, first_upper = true)
         if first_upper
-          snake_string.to_s
-            .gsub(/(?:^|_)([^_\s]+)/) { Regexp.last_match[1].capitalize }
+          snake_string.to_s.gsub(UNDERSCORE_REGEXP) { Regexp.last_match[1].capitalize }
         else
-          parts = snake_string.split('_', 2)
+          parts = snake_string.split(UNDERSCORE, 2)
           parts[0] << camelize(parts[1]) if parts.size > 1
-          parts[0] || ''
+          parts[0] || EMPTY_STRING
         end
       end
 
@@ -43,7 +51,7 @@ module Surrealist
       #
       # @return [String] extracted class
       def extract_class(string)
-        uncapitalize(string.split('::').last)
+        uncapitalize(string.split(NAMESPACES_SEPARATOR).last)
       end
 
       # Extracts n amount of classes from a namespaces and returns a nested hash.
@@ -62,8 +70,8 @@ module Surrealist
       # @return [Hash] a nested hash.
       def break_namespaces(klass, camelize:, nesting_level:)
         Surrealist::ExceptionRaiser.raise_invalid_nesting!(nesting_level) unless nesting_level > 0
-        arr = klass.split('::')
-        arr.last(nesting_level).reverse.inject({}) do |a, n|
+
+        klass.split(NAMESPACES_SEPARATOR).last(nesting_level).reverse.inject({}) do |a, n|
           camelize ? Hash[camelize(uncapitalize(n), false).to_sym => a] : Hash[underscore(n).to_sym => a]
         end
       end

data/lib/surrealist/type_helper.rb

@@ -2,7 +2,7 @@
 
 module Surrealist
   # Service class for type checking
-  class TypeHelper
+  module TypeHelper
     # Dry-types class matcher
     DRY_TYPE_CLASS = 'Dry::Types'.freeze
 
@@ -18,7 +18,7 @@ module Surrealist
         return true if type == Any
 
         if type == Bool
-          [true, false].include?(value)
+          Surrealist::Carrier::BOOLEANS.include?(value)
         elsif dry_type?(type)
           type.try(value).success?
         else

data/lib/surrealist/value_assigner.rb

@@ -2,7 +2,7 @@
 
 module Surrealist
   # A class that determines the correct value to return for serialization. May descend recursively.
-  class ValueAssigner
+  module ValueAssigner
     class << self
       # Assigns value returned from a method to a corresponding key in the schema hash.
       #

data/lib/surrealist/vars_helper.rb

@@ -0,0 +1,65 @@
+module Surrealist
+  # Module for finding and setting hash into vars
+  module VarsHelper
+    # Instance variable name that is set by SchemaDefiner
+    INSTANCE_VARIABLE = '@__surrealist_schema'.freeze
+    # Instance's parent instance variable name that is set by SchemaDefiner
+    PARENT_VARIABLE = '@__surrealist_schema_parent'.freeze
+    # Class variable name that is set by SchemaDefiner
+    CLASS_VARIABLE = '@@__surrealist_schema'.freeze
+    # Regexp to resolve ROM structure
+    ROM_REGEXP = /ROM::Struct/o
+    # Instance variable that keeps serializer class
+    SERIALIZER_CLASS = '@__surrealist_serializer'.freeze
+
+    class << self
+      # Find the schema
+      #
+      # @param [Class] klass Class that included Surrealist
+      #
+      # @return [Hash] Found hash
+      def find_schema(klass)
+        if use_class_var?(klass)
+          klass.class_variable_get(CLASS_VARIABLE) if klass.class_variable_defined?(CLASS_VARIABLE)
+        else
+          klass.instance_variable_get(INSTANCE_VARIABLE)
+        end
+      end
+
+      # Setting schema into var
+      #
+      # @param [Class] klass Class that included Surrealist
+      # @param [Hash] hash Schema hash
+      def set_schema(klass, hash)
+        if use_class_var?(klass)
+          klass.class_variable_set(CLASS_VARIABLE, hash)
+        else
+          klass.instance_variable_set(INSTANCE_VARIABLE, hash)
+        end
+      end
+
+      # Checks if there is a serializer defined for a given class and returns it
+      #
+      # @param [Class] klass a class to check
+      #
+      # @return [Class | nil]
+      def find_serializer(klass)
+        klass.instance_variable_get(SERIALIZER_CLASS)
+      end
+
+      # Sets a serializer for class
+      #
+      # @param [Class] self_class class of object that points to serializer
+      # @param [Class] serializer_class class of serializer
+      def set_serializer(self_class, serializer_class)
+        self_class.instance_variable_set(SERIALIZER_CLASS, serializer_class)
+      end
+
+      private
+
+      def use_class_var?(klass)
+        klass.name =~ ROM_REGEXP
+      end
+    end
+  end
+end

data/lib/surrealist/version.rb

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

data/lib/surrealist.rb

@@ -1,31 +1,27 @@
 # frozen_string_literal: true
 
-require 'surrealist/any'
-require 'surrealist/bool'
-require 'surrealist/builder'
-require 'surrealist/carrier'
-require 'surrealist/class_methods'
-require 'surrealist/copier'
-require 'surrealist/exception_raiser'
-require 'surrealist/hash_utils'
-require 'surrealist/instance_methods'
-require 'surrealist/schema_definer'
-require 'surrealist/string_utils'
-require 'surrealist/helper'
-require 'surrealist/type_helper'
-require 'surrealist/value_assigner'
 require 'json'
+require_relative 'surrealist/any'
+require_relative 'surrealist/bool'
+require_relative 'surrealist/builder'
+require_relative 'surrealist/carrier'
+require_relative 'surrealist/class_methods'
+require_relative 'surrealist/copier'
+require_relative 'surrealist/exception_raiser'
+require_relative 'surrealist/hash_utils'
+require_relative 'surrealist/helper'
+require_relative 'surrealist/instance_methods'
+require_relative 'surrealist/schema_definer'
+require_relative 'surrealist/serializer'
+require_relative 'surrealist/string_utils'
+require_relative 'surrealist/type_helper'
+require_relative 'surrealist/value_assigner'
+require_relative 'surrealist/vars_helper'
 
 # Main module that provides the +json_schema+ class method and +surrealize+ instance method.
 module Surrealist
   # Default namespaces nesting level
   DEFAULT_NESTING_LEVEL = 666
-  # Instance variable name that is set by SchemaDefiner
-  INSTANCE_VARIABLE = '@__surrealist_schema'.freeze
-  # Instance's parent instance variable name that is set by SchemaDefiner
-  PARENT_VARIABLE = '@__surrealist_schema_parent'.freeze
-  # Class variable name that is set by SchemaDefiner
-  CLASS_VARIABLE = '@@__surrealist_schema'.freeze
 
   class << self
     # @param [Class] base class to include/extend +Surrealist+.
@@ -35,15 +31,19 @@ module Surrealist
     end
 
     # Iterates over a collection of Surrealist Objects and
-    # maps surrealize to each record.
+    # maps surrealize to each object.
     #
     # @param [Object] collection of instances of a class that has +Surrealist+ included.
-    # @param [Boolean] camelize optional argument for converting hash to camelBack.
-    # @param [Boolean] include_root optional argument for having the root key of the resulting hash
+    # @param [Boolean] [optional] camelize optional argument for converting hash to camelBack.
+    # @param [Boolean] [optional] include_root optional argument for having the root key of the resulting hash
     #   as instance's class name.
-    # @param [String] root optional argument for using a specified root key for the resulting hash
+    # @param [Boolean] [optional] include_namespaces optional argument for having root key as a nested hash of
+    #   instance's namespaces. Animal::Cat.new.surrealize -> (animal: { cat: { weight: '3 kilos' } })
+    # @param [String] [optional] root optional argument for using a specified root key for the hash.
+    # @param [Integer] [optional] namespaces_nesting_level level of namespaces nesting.
+    # @param [Boolean] [optional] raw optional argument for specifying the expected output format.
     #
-    # @return [Object] the Collection#map with elements being json-formatted string corresponding
+    # @return [JSON | Hash] the Collection#map with elements being json-formatted string corresponding
     #   to the schema provided in the object's class. Values will be taken from the return values
     #   of appropriate methods from the object.
     #
@@ -53,30 +53,38 @@ module Surrealist
     #   Surrealist.surrealize_collection(User.all)
     #   # => "[{\"name\":\"Nikita\",\"age\":23}, {\"name\":\"Alessandro\",\"age\":24}]"
     #   # For more examples see README
-    def surrealize_collection(collection, camelize: false, include_root: false, include_namespaces: false, root: nil, namespaces_nesting_level: DEFAULT_NESTING_LEVEL, raw: false) # rubocop:disable Metrics/LineLength
+    def surrealize_collection(collection, **args)
       raise Surrealist::ExceptionRaiser.raise_invalid_collection! unless collection.respond_to?(:each)
 
-      result = collection.map do |record|
-        if Helper.surrealist?(record.class)
-          record.build_schema(
-            camelize: camelize,
-            include_root: include_root,
-            include_namespaces: include_namespaces,
-            root: root,
-            namespaces_nesting_level: namespaces_nesting_level,
-          )
-        else
-          record
-        end
+      result = collection.map do |object|
+        Helper.surrealist?(object.class) ? __build_schema(object, args) : object
       end
 
-      raw ? result : JSON.dump(result)
+      args[:raw] ? result : JSON.dump(result)
+    end
+
+    # Dumps the object's methods corresponding to the schema
+    # provided in the object's class and type-checks the values.
+    #
+    # @param [Boolean] [optional] camelize optional argument for converting hash to camelBack.
+    # @param [Boolean] [optional] include_root optional argument for having the root key of the resulting hash
+    #   as instance's class name.
+    # @param [Boolean] [optional] include_namespaces optional argument for having root key as a nested hash of
+    #   instance's namespaces. Animal::Cat.new.surrealize -> (animal: { cat: { weight: '3 kilos' } })
+    # @param [String] [optional] root optional argument for using a specified root key for the hash
+    # @param [Integer] [optional] namespaces_nesting_level level of namespaces nesting.
+    #
+    # @return [String] a json-formatted string corresponding to the schema
+    #   provided in the object's class. Values will be taken from the return values
+    #   of appropriate methods from the object.
+    def surrealize(instance:, **args)
+      JSON.dump(build_schema(instance: instance, **args))
     end
 
     # Builds hash from schema provided in the object's class and type-checks the values.
     #
     # @param [Object] instance of a class that has +Surrealist+ included.
-    # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
+    # @param [Hash] args optional arguments
     #
     # @return [Hash] a hash corresponding to the schema
     #   provided in the object's class. Values will be taken from the return values
@@ -112,8 +120,9 @@ module Surrealist
     #   User.new.build_schema
     #   # => { name: 'Nikita', age: 23 }
     #   # For more examples see README
-    def build_schema(instance:, carrier:)
-      schema = find_schema(instance)
+    def build_schema(instance:, **args)
+      carrier = Surrealist::Carrier.call(args)
+      schema = Surrealist::VarsHelper.find_schema(instance.class)
 
       Surrealist::ExceptionRaiser.raise_unknown_schema!(instance) if schema.nil?
 
@@ -129,14 +138,21 @@ module Surrealist
 
     private
 
-    def find_schema(instance)
-      delegatee = instance.class.instance_variable_get(PARENT_VARIABLE)
-      maybe_schema = (delegatee || instance.class).instance_variable_get(INSTANCE_VARIABLE)
-      maybe_schema || (instance.class.class_variable_get(CLASS_VARIABLE) if klass_var_defined?(instance))
-    end
-
-    def klass_var_defined?(instance)
-      instance.class.class_variable_defined?(CLASS_VARIABLE)
+    # Checks if there is a serializer (< Surrealist::Serializer) defined for the object and delegates
+    # surrealization to it.
+    #
+    # @param [Object] object serializable object
+    # @param [Hash] args optional arguments passed to +surrealize_collection+
+    #
+    # @return [Hash] a hash corresponding to the schema
+    #   provided in the object's class. Values will be taken from the return values
+    #   of appropriate methods from the object.
+    def __build_schema(object, **args)
+      if (serializer = Surrealist::VarsHelper.find_serializer(object.class))
+        serializer.new(object, args[:context].to_h).build_schema(args)
+      else
+        build_schema(instance: object, **args)
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: surrealist
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Nikita Esaulov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-22 00:00:00.000000000 Z
+date: 2018-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,9 +114,11 @@ files:
 - lib/surrealist/helper.rb
 - lib/surrealist/instance_methods.rb
 - lib/surrealist/schema_definer.rb
+- lib/surrealist/serializer.rb
 - lib/surrealist/string_utils.rb
 - lib/surrealist/type_helper.rb
 - lib/surrealist/value_assigner.rb
+- lib/surrealist/vars_helper.rb
 - lib/surrealist/version.rb
 - surrealist-icon.png
 - surrealist.gemspec
@@ -140,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.2
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: A gem that provides DSL for serialization of plain old Ruby objects to JSON