Specs & Integration for ActiveRecord and ROM

Gemfile

@@ -12,6 +12,7 @@ group :development, :test do
   gem 'dry-types', '~> 0.12'
   gem 'pry'
   gem 'rom', '~> 3.0'
+  gem 'rom-repository'
   gem 'rom-sql'
   gem 'sequel'
   gem 'sqlite3'

gemfiles/activerecord42.gemfile

@@ -10,6 +10,7 @@ group :development, :test do
   gem 'dry-struct', '~> 0.3'
   gem 'dry-types', '~> 0.12'
   gem 'rom', '~> 3.0'
+  gem 'rom-repository'
   gem 'rom-sql'
   gem 'sequel'
   gem 'sqlite3'

lib/surrealist.rb

@@ -20,6 +20,15 @@
 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
+  # An instance of Carrier with default params
+  NULL_CARRIER = Carrier.new(false, false, false,
+                             nil, DEFAULT_NESTING_LEVEL).freeze
 
   class << self
     # @param [Class] base class to include/extend +Surrealist+.
@@ -31,7 +40,7 @@ def included(base)
     # 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.
@@ -107,8 +116,7 @@ def surrealize_collection(collection, camelize: false, include_root: false, incl
     #   # => { 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?
 
@@ -121,5 +129,17 @@ def build_schema(instance:, carrier:)
       hash = Builder.call(schema: normalized_schema, instance: instance)
       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

lib/surrealist/builder.rb

@@ -4,6 +4,7 @@ module Surrealist
   # A class that builds a hash from the schema and type-checks the values.
   class Builder
     class << self
+      Schema = Struct.new(:key, :value).freeze
       # 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.
@@ -16,10 +17,9 @@ class << self
       def call(schema:, instance:)
         schema.each do |schema_key, schema_value|
           if schema_value.is_a?(Hash)
-            Builder.call(schema: schema_value,
-                         instance: instance.respond_to?(schema_key) ? instance.send(schema_key) : instance)
+            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
@@ -29,7 +29,32 @@ def call(schema:, instance:)
               "in the schema that doesn't have a corresponding method."
       end
 
-      Schema = Struct.new(:key, :value)
+      private
+
+      def check_for_ar(schema, instance, key, value)
+        if ar_collection?(instance, key)
+          construct_collection(schema, instance, key, value)
+        else
+          Builder.call(schema: value,
+                       instance: instance.respond_to?(key) ? instance.send(key) : instance)
+        end
+      end
+
+      def ar_collection?(instance, schema_key)
+        defined?(ActiveRecord) &&
+          instance.respond_to?(schema_key) &&
+          instance.send(schema_key).is_a?(ActiveRecord::Relation)
+      end
+
+      def construct_collection(schema, instance, schema_key, schema_value)
+        schema[schema_key] = []
+        instance.send(schema_key).each do |i|
+          schema[schema_key] << call(
+            schema:   Copier.deep_copy(hash: schema_value, carrier: Surrealist::NULL_CARRIER),
+            instance: i,
+          )
+        end
+      end
     end
   end
 end

lib/surrealist/schema_definer.rb

@@ -15,7 +15,11 @@ class SchemaDefiner
     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

lib/surrealist/value_assigner.rb

@@ -7,7 +7,7 @@ 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] containg a single schema key and value
+      # @param [Struct] schema containing a single schema key and value
       #
       # @return [Hash] schema
       def assign(instance:, schema:)
@@ -30,13 +30,23 @@ def assign(instance:, schema:)
       # 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] containing a single schema key and value
-      #
-      # @raise +Surrealist::InvalidTypeError+ if type-check failed at some point.
+      # @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}."

spec/carrier_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative './carriers/params'
-
 RSpec.describe Surrealist::Carrier do
   describe '#call' do
     context 'invalid arguments' do