surrealist 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c83fe19569dc43edfa87a5a0b8fe4fcbd2f74742
-  data.tar.gz: 8dd0d5fc5e2c1450468bd2d16a026d2a5d6e949e
+SHA256:
+  metadata.gz: ddb587c43e017b7be30cbcddf5ae8ee32094cff322233dbd89ed32c6bd8d5f7f
+  data.tar.gz: 9ac93b85f00189ff0937e056ac1475243e9364a78c70d5c570583028f4073f93
 SHA512:
-  metadata.gz: 0a47f6780ffeba32e2b748e588eafb8abf3399d9f464412c0a4e95076809e93b92e346180c2560cb4b1689824accd959d1c2794e8cafa9dad520fe70c6e83243
-  data.tar.gz: afb0df3267229cd475d387449b3246fbe39a5ddb9927de730b229293b82645c946e6f5e3179fe04dcd31533871050453c6dbc1fd33fb86e3b5165626f707f8f7
+  metadata.gz: 6ad65631c97a6ab8b77d678fac704d8da83ab0d1f7ca1b263169a643ca0e4fe33aaec846bbecd1504ba28147c83fc878b60232acec75cbb11195d6310ebb0a5a
+  data.tar.gz: 1c2a5350fd1d780dad01df6e5f60f01155c356f319f85e8f623bcb5e87b6bf75cdcc31b6604e309f1a5367d9cceb3279448c85eeea452a4818e27f55adbc5966

data/.hound.yml

@@ -0,0 +1,3 @@
+fail_on_violations: true
+ruby:
+  config_file: .rubocop.yml

data/.rspec

@@ -1,3 +1,2 @@
 --color
---format doc
 --require spec_helper

data/.rubocop.yml

@@ -1,5 +1,7 @@
 AllCops:
   TargetRubyVersion: 2.2
+  Exclude:
+    - './gemfiles/*gemfile'
 
 # Layout
 
@@ -57,7 +59,7 @@ Metrics/MethodLength:
   Max: 15
 
 Metrics/LineLength:
-  Max: 106
+  Max: 110
 
 Metrics/PerceivedComplexity:
   Enabled: false
@@ -87,6 +89,14 @@ Performance/UnfreezeString:
 
 # Style
 
+Style/MixinUsage:
+  Exclude:
+    - spec/**/*rb
+
+Style/DateTime:
+  Exclude:
+    - spec/**/*rb
+
 Style/SingleLineMethods:
   Exclude:
     - spec/**/*rb

data/.travis.yml

@@ -3,11 +3,20 @@ sudo: false
 cache: bundler
 before_install: gem install bundler
 script: bundle exec rake
-rvm:
-  - 2.2.0
-  - 2.2.5
-  - 2.3.1
-  - 2.3.5
-  - 2.4.0
-  - 2.4.2
-  - ruby-head
+matrix:
+  fast_finish: true
+  include:
+    - rvm: ruby-head
+      gemfile: Gemfile
+    - rvm: 2.4.2
+      gemfile: Gemfile
+    - rvm: 2.4.0
+      gemfile: Gemfile
+    - rvm: 2.3.5
+      gemfile: Gemfile
+    - rvm: 2.3.1
+      gemfile: Gemfile
+    - rvm: 2.2.5
+      gemfile: Gemfile
+    - rvm: 2.2.0
+      gemfile: gemfiles/activerecord42.gemfile

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 0.3.0
+
+## Added
+* Full integration for ActiveRecord (@nesaulov, @AlessandroMinali) #37
+* Full integration for ROM (@nesaulov, @AlessandroMinali) #37
+* `root` optional argument (@chrisatanasian) #32
+* Nested records surrealization (@AlessandroMinali) #34
+
+## Fixed
+* Dependencies update (@nesaulov) #48
+
 # 0.2.0
 ## Added
 * `delegate_surrealization_to` class method

data/Gemfile

@@ -8,8 +8,10 @@ group :development, :test do
   gem 'coveralls', require: false
   gem 'data_mapper'
   gem 'dm-sqlite-adapter'
-  gem 'pry'
-  gem 'rom'
+  gem 'dry-struct'
+  gem 'dry-types'
+  gem 'rom', '~> 3.0'
+  gem 'rom-repository'
   gem 'rom-sql'
   gem 'sequel'
   gem 'sqlite3'

data/README.md

@@ -29,6 +29,7 @@ to serialize nested objects and structures. [Introductory blogpost.](https://med
   * [Include root](#include-root)
   * [Include namespaces](#include-namespaces)
   * [Collection Surrealization](#collection-surrealization)
+  * [Root](#root)
   * [Bool and Any](#bool-and-any)
   * [Type errors](#type-errors)
   * [Undefined methods in schema](#undefined-methods-in-schema)
@@ -352,8 +353,43 @@ You can find motivation behind introducing new API versus monkey-patching [here]
 `#surrealize_collection` works for all data structures that respond to `#each`. All ActiveRecord
 features (like associations, inheritance etc) are supported and covered. Other ORMs should work without
 issues as well, tests are in progress. All optional arguments (`camelize`, `include_root` etc) are also supported.
+
+An additional and unique arguement for `#surrealize_collection` is `raw` which is evalauted as a Boolean. If this option is 'truthy' then the results will be an array of surrealized hashes (ie. NOT a JSON string).
+```
+Surrealist.surrealize_collection(users, raw: true)
+# => [{ "name": "Nikita", "age": 23 }, { "name": "Alessandro", "age": 24 }]
+```
 Guides on where to use `#surrealize_collection` vs `#surrealize` for all ORMs are coming.
 
+### Root
+If you want to wrap the resulting JSON into a specified root key, you can pass optional `root` argument
+to `#surrealize` or `#build_schema`. The `root` argument will be stripped of whitespaces.
+``` ruby
+class Cat
+  include Surrealist
+ 
+  json_schema do
+    { weight: String }
+  end
+ 
+  def weight
+    '3 kilos'
+  end
+end
+
+Cat.new.surrealize(root: :kitten)
+# => '{ "kitten": { "weight": "3 kilos" } }'
+Cat.new.surrealize(root: ' kitten ')
+# => '{ "kitten": { "weight": "3 kilos" } }'
+```
+This overrides the `include_root` and `include_namespaces` arguments.
+``` ruby
+Animal::Cat.new.surrealize(include_root: true, root: :kitten)
+# => '{ "kitten": { "weight": "3 kilos" } }'
+Animal::Cat.new.surrealize(include_namespaces: true, root: 'kitten')
+# => '{ "kitten": { "weight": "3 kilos" } }'
+```
+
 ### Bool and Any
 If you have a parameter that is of boolean type, or if you don't care about the type, you
 can use `Bool` and `Any` respectively.

data/Rakefile

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
-require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
-RuboCop::RakeTask.new
 
-task default: %i[rubocop spec]
+task default: :spec

data/gemfiles/activerecord42.gemfile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+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'
+  gem 'rom-repository'
+  gem 'rom-sql'
+  gem 'sequel'
+  gem 'sqlite3'
+  gem 'yard', require: false unless ENV['TRAVIS']
+end
+
+gemspec path: '..'

data/lib/surrealist/builder.rb

@@ -3,113 +3,89 @@
 module Surrealist
   # A class that builds a hash from the schema and type-checks the values.
   class Builder
-    # TODO: refactor methods so they don't take so much arguments
-    class << self
-      # A method that goes recursively through the schema hash, defines the values and type-checks them.
-      #
-      # @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.
-      #
-      # @raise +Surrealist::UndefinedMethodError+ if a key defined in the schema
-      #   does not have a corresponding method on the object.
-      #
-      # @return [Hash] a hash that will be dumped into JSON.
-      def call(schema:, instance:)
-        schema.each do |schema_key, schema_value|
-          if schema_value.is_a?(Hash)
-            parse_hash(hash: schema_value, schema: schema, instance: instance, key: schema_key)
-          else
-            type = schema_value
-            schema_value = instance.is_a?(Hash) ? instance[schema_key] : instance.send(schema_key)
-            assign_value(method: schema_key, value: schema_value, type: type) do |coerced_value|
-              schema[schema_key] = coerced_value
-            end
-          end
-        end
-      rescue NoMethodError => e
-        raise Surrealist::UndefinedMethodError,
-              "#{e.message}. You have probably defined a key " \
-              "in the schema that doesn't have a corresponding method."
-      end
+    # Struct to carry schema along
+    Schema = Struct.new(:key, :value).freeze
 
-      private
+    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.
+    def initialize(carrier:, schema:, instance:)
+      @carrier = carrier
+      @schema = schema
+      @instance = instance
+    end
 
-      # Checks if hash represents methods on the instance.
-      #
-      # @param [Hash] hash a value from the schema hash.
-      # @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.
-      # @param [Symbol] key a key from the schema hash.
-      #
-      # @return [Hash] schema
-      def parse_hash(hash:, schema:, instance:, key:)
-        if instance.respond_to?(key)
-          maybe_take_values_from_instance(instance: instance, method: key, hash: hash, schema: schema)
+    # A method that goes recursively through the schema hash, defines the values and type-checks them.
+    #
+    # @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.
+    #
+    # @raise +Surrealist::UndefinedMethodError+ if a key defined in the schema
+    #   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)
+      schema.each do |schema_key, schema_value|
+        if schema_value.is_a?(Hash)
+          check_for_ar(schema, instance, schema_key, schema_value)
         else
-          call(schema: hash, instance: instance)
+          ValueAssigner.assign(schema:   Schema.new(schema_key, schema_value),
+                               instance: instance) { |coerced_value| schema[schema_key] = coerced_value }
         end
       end
+    rescue NoMethodError => e
+      Surrealist::ExceptionRaiser.raise_invalid_key!(e)
+    end
 
-      # Checks if object's method include schema keys.
-      #
-      # @param [Object] instance the instance of the object which methods from the schema are called on.
-      # @param [Symbol] method a key from the schema hash representing a method on the instance.
-      # @param [Hash] hash a value from the schema hash.
-      # @param [Hash] schema the schema defined in the object's class.
-      #
-      # @return [Hash] schema
-      def maybe_take_values_from_instance(instance:, method:, hash:, schema:)
-        object = instance.send(method)
+    private
 
-        hash.each do |key, value|
-          if object.methods.include?(key)
-            take_values_from_instance(instance: object, value: value, hash: hash, key: key,
-                                      schema: schema, method: method)
-          else
-            call(schema: hash, instance: object)
-          end
-        end
+    # Checks if result is an instance of ActiveRecord::Relation
+    #
+    # @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.
+    # @param [Symbol] key the symbol that represents method on the instance
+    # @param [Any] value returned when key is called on instance
+    #
+    # @return [Hash] the schema hash
+    def check_for_ar(schema, instance, key, value)
+      if ar_collection?(instance, key)
+        construct_collection(schema, instance, key, value)
+      else
+        call(schema:   value,
+             instance: instance.respond_to?(key) ? instance.send(key) : instance)
       end
+    end
 
-      # Invokes methods on the instance and puts return values into the schema hash.
-      #
-      # @param [Object] instance the instance of the object which methods from the schema are called on.
-      # @param [Class | Hash] value either type of value or a hash.
-      # @param [Hash] hash a value from the schema hash.
-      # @param [Hash] schema the schema defined in the object's class.
-      # @param [Symbol] method a key from the schema hash representing a method on the instance.
-      #
-      # @return [Hash] schema
-      def take_values_from_instance(instance:, value:, hash:, key:, schema:, method:)
-        result = instance.send(key)
-
-        if value.is_a?(Hash)
-          parse_hash(hash: value, schema: hash, instance: result, key: key)
-        else
-          type = value
-          assign_value(method: key, value: result, type: type) do |coerced_value|
-            schema[method] = schema[method].merge(key => coerced_value)
-          end
-        end
-      end
+    # Checks if the instance responds to the method and whether it returns an AR::Relation
+    #
+    # @param [Object] instance
+    # @param [Symbol] method
+    #
+    # @return [Boolean]
+    def ar_collection?(instance, method)
+      defined?(ActiveRecord) &&
+        instance.respond_to?(method) &&
+        instance.send(method).is_a?(ActiveRecord::Relation)
+    end
 
-      # Assigns value returned from a method to a corresponding key in the schema hash.
-      #
-      # @param [Symbol] method a key from the schema hash representing a method on the instance.
-      # @param [Object] value a value that has to be type-checked.
-      # @param [Class] type class representing data type.
-      #
-      # @raise +Surrealist::InvalidTypeError+ if type-check failed at some point.
-      #
-      # @return [Hash] schema
-      def assign_value(method:, value:, type:, &_block)
-        if TypeHelper.valid_type?(value: value, type: type)
-          value = TypeHelper.coerce(type: type, value: value)
-          yield value
-        else
-          raise Surrealist::InvalidTypeError,
-                "Wrong type for key `#{method}`. Expected #{type}, got #{value.class}."
-        end
+    # Makes the value of appropriate key of the schema an array and pushes in results of iterating through
+    #   records and surrealizing them
+    #
+    # @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.
+    # @param [Symbol] key the symbol that represents method on the instance
+    # @param [Any] value returned when key is called on instance
+    #
+    # @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,
+        )
       end
     end
   end

data/lib/surrealist/carrier.rb

@@ -10,21 +10,23 @@ module Surrealist
     #   as instance's class name.
     # @param [Boolean] 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 resulting hash
     # @param [Integer] namespaces_nesting_level level of namespaces nesting.
     #
     # @raise ArgumentError if types of arguments are wrong.
     #
     # @return [Carrier] self if type checks were passed.
-    def self.call(camelize:, include_root:, include_namespaces:, namespaces_nesting_level:)
-      new(camelize, include_root, include_namespaces, namespaces_nesting_level).sanitize!
+    def self.call(camelize:, include_root:, include_namespaces:, root:, namespaces_nesting_level:)
+      new(camelize, include_root, include_namespaces, root, namespaces_nesting_level).sanitize!
     end
 
-    attr_reader :camelize, :include_root, :include_namespaces, :namespaces_nesting_level
+    attr_reader :camelize, :include_root, :include_namespaces, :root, :namespaces_nesting_level
 
-    def initialize(camelize, include_root, include_namespaces, 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
     end
 
@@ -34,6 +36,8 @@ module Surrealist
     def sanitize!
       check_booleans!
       check_namespaces_nesting!
+      check_root!
+      strip_root!
       self
     end
 
@@ -65,5 +69,18 @@ module Surrealist
         Surrealist::ExceptionRaiser.raise_invalid_nesting!(namespaces_nesting_level)
       end
     end
+
+    # 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)
+        Surrealist::ExceptionRaiser.raise_invalid_root!(root)
+      end
+    end
+
+    # Strips root of empty whitespaces
+    def strip_root!
+      root.is_a?(String) && @root = root.strip
+    end
   end
 end

data/lib/surrealist/class_methods.rb

@@ -87,9 +87,7 @@ module Surrealist
     def delegate_surrealization_to(klass)
       raise TypeError, "Expected type of Class got #{klass.class} instead" unless klass.is_a?(Class)
 
-      unless klass.included_modules.include?(Surrealist)
-        Surrealist::ExceptionRaiser.raise_invalid_schema_delegation!
-      end
+      Surrealist::ExceptionRaiser.raise_invalid_schema_delegation! unless Helper.surrealist?(klass)
 
       instance_variable_set('@__surrealist_schema_parent', klass)
     end

data/lib/surrealist/copier.rb

@@ -14,19 +14,36 @@ module Surrealist
       def deep_copy(hash:, klass: false, carrier:)
         namespaces_condition = carrier.include_namespaces || carrier.namespaces_nesting_level != DEFAULT_NESTING_LEVEL # rubocop:disable Metrics/LineLength
 
-        return copy_hash(hash) unless carrier.include_root || namespaces_condition
+        if !klass && (carrier.include_root || namespaces_condition)
+          Surrealist::ExceptionRaiser.raise_unknown_root!
+        end
+
+        copied_and_possibly_wrapped_hash(hash, klass, carrier, namespaces_condition)
+      end
 
-        Surrealist::ExceptionRaiser.raise_unknown_root! unless klass
+      private
 
-        if namespaces_condition
+      # Deeply copies the schema hash and wraps it if there is a need to.
+      #
+      # @param [Object] hash object to be copied.
+      # @param [String] klass instance's class name.
+      # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
+      # @param [Bool] namespaces_condition whether to wrap into namespace.
+      #
+      # @return [Hash] deeply copied hash, possibly wrapped.
+      def copied_and_possibly_wrapped_hash(hash, klass, carrier, namespaces_condition)
+        if carrier.root
+          wrap_schema_into_root(schema: hash, carrier: carrier, root: carrier.root.to_s)
+        elsif namespaces_condition
           wrap_schema_into_namespace(schema: hash, klass: klass, carrier: carrier)
         elsif carrier.include_root
-          wrap_schema_into_root(schema: hash, klass: klass, carrier: carrier)
+          actual_class = Surrealist::StringUtils.extract_class(klass)
+          wrap_schema_into_root(schema: hash, carrier: carrier, root: actual_class)
+        else
+          copy_hash(hash)
         end
       end
 
-      private
-
       # Goes through the hash recursively and deeply copies it.
       #
       # @param [Hash] hash the hash to be copied.
@@ -42,16 +59,15 @@ module Surrealist
       # Wraps schema into a root key if `include_root` is passed to Surrealist.
       #
       # @param [Hash] schema schema hash.
-      # @param [String] klass name of the class where schema is defined.
       # @param [Object] carrier instance of Carrier class that carries arguments passed to +surrealize+
+      # @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:, klass:, carrier:)
-        actual_class = Surrealist::StringUtils.extract_class(klass)
+      def wrap_schema_into_root(schema:, carrier:, root:)
         root_key = if carrier.camelize
-                     Surrealist::StringUtils.camelize(actual_class, false).to_sym
+                     Surrealist::StringUtils.camelize(root, false).to_sym
                    else
-                     Surrealist::StringUtils.underscore(actual_class).to_sym
+                     Surrealist::StringUtils.underscore(root).to_sym
                    end
         result = Hash[root_key => {}]
         copy_hash(schema, wrapper: result[root_key])

data/lib/surrealist/exception_raiser.rb

@@ -5,25 +5,25 @@ module Surrealist
   class UnknownSchemaError < RuntimeError; end
 
   # Error class for classes with +json_schema+ defined not as a hash.
-  class InvalidSchemaError < RuntimeError; end
+  class InvalidSchemaError < ArgumentError; end
 
   # Error class for +NoMethodError+.
-  class UndefinedMethodError < RuntimeError; end
+  class UndefinedMethodError < ArgumentError; end
 
   # Error class for failed type-checks.
   class InvalidTypeError < TypeError; end
 
   # Error class for undefined root keys for schema wrapping.
-  class UnknownRootError < RuntimeError; end
+  class UnknownRootError < ArgumentError; end
 
   # Error class for undefined class to delegate schema.
-  class InvalidSchemaDelegation < RuntimeError; end
+  class InvalidSchemaDelegation < ArgumentError; end
 
   # Error class for invalid object given to iteratively apply surrealize.
   class InvalidCollectionError < ArgumentError; end
 
   # Error class for cases where +namespaces_nesting_level+ is set to 0.
-  class InvalidNestingLevel < RuntimeError; end
+  class InvalidNestingLevel < ArgumentError; end
 
   # A class that raises all Surrealist exceptions
   class ExceptionRaiser
@@ -67,6 +67,24 @@ module Surrealist
         raise ArgumentError,
               "Expected `namespaces_nesting_level` to be a positive integer, got: #{value}"
       end
+
+      # Raises ArgumentError if root is not nil, a non-empty string or symbol.
+      #
+      # @raise ArgumentError
+      def raise_invalid_root!(value)
+        raise ArgumentError,
+              "Expected `root` to be nil, a non-empty string, or symbol, got: #{value}"
+      end
+
+      # Raises ArgumentError if a key defined in the schema does not have a corresponding
+      # method on the object.
+      #
+      # @raise Surrealist::UndefinedMethodError
+      def raise_invalid_key!(e)
+        raise Surrealist::UndefinedMethodError,
+              "#{e.message}. You have probably defined a key " \
+              "in the schema that doesn't have a corresponding method."
+      end
     end
   end
 end

data/lib/surrealist/helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+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
+    end
+  end
+end

data/lib/surrealist/instance_methods.rb

@@ -11,6 +11,7 @@ module Surrealist
     #   as instance's class name.
     # @param [Boolean] 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.
     #
     # @return [String] a json-formatted string corresponding to the schema
@@ -47,23 +48,25 @@ module Surrealist
     #   User.new.surrealize
     #   # => "{\"name\":\"Nikita\",\"age\":23}"
     #   # For more examples see README
-    def surrealize(camelize: false, include_root: false, include_namespaces: false, namespaces_nesting_level: DEFAULT_NESTING_LEVEL) # rubocop:disable Metrics/LineLength
+    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,
         ),
       )
     end
 
     # Invokes +Surrealist+'s class method +build_schema+
-    def build_schema(camelize: false, include_root: false, include_namespaces: false, namespaces_nesting_level: DEFAULT_NESTING_LEVEL) # rubocop:disable Metrics/LineLength
+    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,
       )
 

data/lib/surrealist/schema_definer.rb

@@ -15,7 +15,11 @@ module Surrealist
     def self.call(klass, hash)
       raise Surrealist::InvalidSchemaError, 'Schema should be defined as a hash' unless hash.is_a?(Hash)
 
-      klass.instance_variable_set('@__surrealist_schema', hash)
+      if klass.name =~ /ROM::Struct/
+        klass.class_variable_set('@@__surrealist_schema', hash)
+      else
+        klass.instance_variable_set('@__surrealist_schema', hash)
+      end
     end
   end
 end

data/lib/surrealist/value_assigner.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Surrealist
+  # A class that determines the correct value to return for serialization. May descend recursively.
+  class ValueAssigner
+    class << self
+      # Assigns value returned from a method to a corresponding key in the schema hash.
+      #
+      # @param [Object] instance the instance of the object which methods from the schema are called on.
+      # @param [Struct] schema containing a single schema key and value
+      #
+      # @return [Hash] schema
+      def assign(instance:, schema:)
+        value = raw_value(instance: instance, schema: schema)
+
+        # array to track and prevent infinite self references in surrealization
+        @stack ||= []
+
+        if value.respond_to?(:build_schema)
+          yield assign_nested_record(instance: instance, value: value)
+        elsif value.respond_to?(:each) && !value.empty? && value.all? { |v| Helper.surrealist?(v.class) }
+          yield assign_nested_collection(instance: instance, value: value)
+        else
+          yield value
+        end
+      end
+
+      private
+
+      # Generates first pass of serializing value, doing type check and coercion
+      #
+      # @param [Object] instance the instance of the object which methods from the schema are called on.
+      # @param [Struct] schema containing a single schema key and value
+      #
+      # @return [Object] value to be further processed
+      def raw_value(instance:, schema:)
+        value = instance.is_a?(Hash) ? instance[schema.key] : instance.send(schema.key)
+        coerce_value(value, schema: schema)
+      end
+
+      # Coerces value if type check is passed
+      #
+      # @param [Object] value the value to be checked and coerced
+      # @param [Struct] schema containing a single schema key and value
+      #
+      # @raise +Surrealist::InvalidTypeError+ if type-check failed at some point.
+      #
+      # @return [Object] value to be further processed
+      def coerce_value(value, schema:)
+        unless TypeHelper.valid_type?(value: value, type: schema.value)
+          raise Surrealist::InvalidTypeError,
+                "Wrong type for key `#{schema.key}`. Expected #{schema.value}, got #{value.class}."
+        end
+        TypeHelper.coerce(type: schema.value, value: value)
+      end
+
+      # Assists in recursively generating schema for records while preventing infinite self-referencing
+      #
+      # @param [Object] instance the instance of the object which methods from the schema are called on.
+      # @param [Object] value a value that has to be type-checked.
+      #
+      # @return [Array] of schemas
+      def assign_nested_collection(instance:, value:)
+        return if @stack.include?(value.first.class)
+        @stack << instance.class << value.first.class
+        result = Surrealist.surrealize_collection(value, raw: true)
+        @stack.delete(instance.class)
+        result
+      end
+
+      # Assists in recursively generating schema for a record while preventing infinite self-referencing
+      #
+      # @param [Object] instance the instance of the object which methods from the schema are called on.
+      # @param [Object] value a value that has to be type-checked.
+      #
+      # @return [Hash] schema
+      def assign_nested_record(instance:, value:)
+        return if @stack.include?(value.class)
+        @stack << instance.class
+        result = value.build_schema
+        @stack.delete(instance.class)
+        result
+      end
+    end
+  end
+end

data/lib/surrealist/version.rb

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

data/lib/surrealist.rb

@@ -11,13 +11,21 @@ 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'
 
 # 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+.
@@ -29,10 +37,11 @@ module Surrealist
     # Iterates over a collection of Surrealist Objects and
     # maps surrealize to each record.
     #
-    # @param [Object] Collection of instances of a class that has +Surrealist+ included.
+    # @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
     #   as instance's class name.
+    # @param [String] root optional argument for using a specified root key for the resulting hash
     #
     # @return [Object] 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
@@ -44,19 +53,24 @@ 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, namespaces_nesting_level: DEFAULT_NESTING_LEVEL) # rubocop:disable Metrics/LineLength
-      unless collection.respond_to?(:each)
-        raise Surrealist::ExceptionRaiser.raise_invalid_collection!
+    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
+      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
       end
 
-      JSON.dump(collection.map do |record|
-        record.build_schema(
-          camelize: camelize,
-          include_root: include_root,
-          include_namespaces: include_namespaces,
-          namespaces_nesting_level: namespaces_nesting_level,
-        )
-      end)
+      raw ? result : JSON.dump(result)
     end
 
     # Builds hash from schema provided in the object's class and type-checks the values.
@@ -99,8 +113,7 @@ module Surrealist
     #   # => { name: 'Nikita', age: 23 }
     #   # For more examples see README
     def build_schema(instance:, carrier:)
-      delegatee = instance.class.instance_variable_get('@__surrealist_schema_parent')
-      schema = (delegatee || instance.class).instance_variable_get('@__surrealist_schema')
+      schema = find_schema(instance)
 
       Surrealist::ExceptionRaiser.raise_unknown_schema!(instance) if schema.nil?
 
@@ -110,8 +123,20 @@ module Surrealist
         carrier: carrier,
       )
 
-      hash = Builder.call(schema: normalized_schema, instance: instance)
+      hash = Builder.new(carrier: carrier, schema: normalized_schema, instance: instance).call
       carrier.camelize ? Surrealist::HashUtils.camelize_hash(hash) : hash
     end
+
+    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)
+    end
   end
 end

data/surrealist.gemspec

@@ -24,10 +24,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   spec.required_ruby_version = '>= 2.2.0'
 
-  spec.add_development_dependency 'bundler', '~> 1.15'
-  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'bundler', '~> 1.16'
   spec.add_development_dependency 'pry', '~> 0.11'
-  spec.add_development_dependency 'rspec', '~> 3.6'
-  spec.add_development_dependency 'dry-types', '~> 0.12'
-  spec.add_development_dependency 'rubocop', '~> 0.50.0'
+  spec.add_development_dependency 'rake', '~> 12.3'
+  spec.add_development_dependency 'rspec', '~> 3.7'
+  spec.add_development_dependency 'rubocop', '0.51.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: surrealist
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Nikita Esaulov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-14 00:00:00.000000000 Z
+date: 2017-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,28 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '1.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '12.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '1.16'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -53,47 +39,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.11'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '12.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '12.3'
 - !ruby/object:Gem::Dependency
-  name: dry-types
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '3.7'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.50.0
+        version: 0.51.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.50.0
+        version: 0.51.0
 description: A gem that provides DSL for serialization of plain old Ruby objects to
   JSON in a declarative style by defining a `schema`. It also provides a trivial type
   checking in the runtime before serialization.
@@ -104,6 +90,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".hound.yml"
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
@@ -114,6 +101,7 @@ files:
 - README.md
 - Rakefile
 - bin/console
+- gemfiles/activerecord42.gemfile
 - lib/surrealist.rb
 - lib/surrealist/any.rb
 - lib/surrealist/bool.rb
@@ -123,10 +111,12 @@ files:
 - lib/surrealist/copier.rb
 - lib/surrealist/exception_raiser.rb
 - lib/surrealist/hash_utils.rb
+- lib/surrealist/helper.rb
 - lib/surrealist/instance_methods.rb
 - lib/surrealist/schema_definer.rb
 - lib/surrealist/string_utils.rb
 - lib/surrealist/type_helper.rb
+- lib/surrealist/value_assigner.rb
 - lib/surrealist/version.rb
 - surrealist-icon.png
 - surrealist.gemspec
@@ -150,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.2
 signing_key: 
 specification_version: 4
 summary: A gem that provides DSL for serialization of plain old Ruby objects to JSON