active_data 1.0.0 → 1.1.0

data/lib/active_data/model/associations/nested_attributes.rb

@@ -4,37 +4,62 @@ module ActiveData
       module NestedAttributes
         extend ActiveSupport::Concern
 
-        DESTROY_ATTRIBUTE = '_destroy'
+        DESTROY_ATTRIBUTE = '_destroy'.freeze
 
         included do
           class_attribute :nested_attributes_options, instance_writer: false
           self.nested_attributes_options = {}
+
+          extend NestedAttributesMethodsExtension
+          prepend PrependMethods
+        end
+
+        module PrependMethods
+          def assign_attributes(attrs)
+            if self.class.nested_attributes_options.present?
+              attrs = attrs.to_unsafe_hash if attrs.respond_to?(:to_unsafe_hash)
+              attrs = attrs.stringify_keys
+
+              nested_attrs = self.class.nested_attributes_options.keys
+                .each_with_object({}) do |association_name, result|
+                  name = "#{association_name}_attributes"
+                  result[name] = attrs.delete(name) if attrs.key?(name)
+                end
+
+              super(attrs.merge!(nested_attrs))
+            else
+              super(attrs)
+            end
+          end
+          alias_method :attributes=, :assign_attributes
         end
 
         class NestedAttributesMethods
           REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |key, value| key == DESTROY_ATTRIBUTE || value.blank? } }
 
           def self.accepts_nested_attributes_for(klass, *attr_names)
-            options = { allow_destroy: false, update_only: false }
+            options = {allow_destroy: false, update_only: false}
             options.update(attr_names.extract_options!)
             options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only)
             options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
 
+            NestedAttributesMethodsExtension.ensure_extended!(klass)
+
             attr_names.each do |association_name|
-              if reflection = klass.reflect_on_association(association_name)
-                klass.nested_attributes_options = klass.nested_attributes_options.merge(association_name.to_sym => options)
-
-                klass.validates_nested association_name if klass.respond_to?(:validates_nested)
-                type = (reflection.collection? ? :collection : :one_to_one)
-                klass.class_eval <<-METHOD, __FILE__, __LINE__ + 1
-                  def #{association_name}_attributes=(attributes)
-                    ActiveData::Model::Associations::NestedAttributes::NestedAttributesMethods
-                      .assign_nested_attributes_for_#{type}_association(self, :#{association_name}, attributes)
-                  end
-                METHOD
-              else
-                raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
-              end
+              reflection = klass.reflect_on_association(association_name)
+              raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?" unless reflection
+              klass.nested_attributes_options = klass.nested_attributes_options.merge(association_name.to_sym => options)
+
+              should_validate_nested = klass.respond_to?(:validates_nested) && !klass.validates_nested?(association_name)
+              klass.validates_nested(association_name) if should_validate_nested
+
+              type = (reflection.collection? ? :collection : :one_to_one)
+              klass.nested_attributes_methods_module.class_eval <<-METHOD, __FILE__, __LINE__ + 1
+                def #{association_name}_attributes=(attributes)
+                  ActiveData::Model::Associations::NestedAttributes::NestedAttributesMethods
+                    .assign_nested_attributes_for_#{type}_association(self, :#{association_name}, attributes)
+                end
+              METHOD
             end
           end
 
@@ -54,7 +79,7 @@ module ActiveData
               assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy]) unless call_reject_if(object, association_name, attributes)
             elsif attributes[primary_attribute_name].present?
               raise ActiveData::ObjectNotFound.new(object, association_name, attributes[primary_attribute_name])
-            elsif !reject_new_object?(object, association_name, attributes)
+            elsif !reject_new_object?(object, association_name, attributes, options)
               assignable_attributes = attributes.except(*unassignable_keys(object))
 
               if existing_record && !existing_record.persisted?
@@ -92,9 +117,7 @@ module ActiveData
               attributes = attributes.with_indifferent_access
 
               if attributes[primary_attribute_name].blank?
-                unless reject_new_object?(object, association_name, attributes)
-                  association.build(attributes.except(*unassignable_keys(object)))
-                end
+                association.build(attributes.except(*unassignable_keys(object))) unless reject_new_object?(object, association_name, attributes, options)
               else
                 existing_record = association.target.detect do |record|
                   primary_attribute_value = record.attribute(primary_attribute_name)
@@ -102,59 +125,53 @@ module ActiveData
                   record.primary_attribute == primary_attribute_value
                 end
                 if existing_record
-                  if !call_reject_if(object, association_name, attributes)
-                    assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
-                  end
-                else
-                  if association.reflection.embedded?
-                    unless reject_new_object?(object, association_name, attributes)
-                      association.reflection.klass.with_sanitize(false) do
-                        association.build(attributes.except(DESTROY_ATTRIBUTE))
-                      end
+                  assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy]) unless call_reject_if(object, association_name, attributes)
+                elsif association.reflection.embedded?
+                  unless reject_new_object?(object, association_name, attributes, options)
+                    association.reflection.klass.with_sanitize(false) do
+                      association.build(attributes.except(DESTROY_ATTRIBUTE))
                     end
-                  else
-                    raise ActiveData::ObjectNotFound.new(object, association_name, attributes[primary_attribute_name])
                   end
+                else
+                  raise ActiveData::ObjectNotFound.new(object, association_name, attributes[primary_attribute_name])
                 end
               end
             end
           end
 
           def self.check_record_limit!(limit, attributes_collection)
-            if limit
-              limit = case limit
-              when Symbol
-                send(limit)
-              when Proc
-                limit.call
-              else
-                limit
-              end
-
-              if limit && attributes_collection.size > limit
-                raise ActiveData::TooManyObjects.new(limit, attributes_collection.size)
-              end
+            limit = case limit
+            when Symbol
+              send(limit)
+            when Proc
+              limit.call
+            else
+              limit
             end
+
+            return unless limit && attributes_collection.size > limit
+
+            raise ActiveData::TooManyObjects.new(limit, attributes_collection.size)
           end
 
           def self.assign_to_or_mark_for_destruction(object, attributes, allow_destroy)
             object.assign_attributes(attributes.except(*unassignable_keys(object)))
-            object.mark_for_destruction if has_destroy_flag?(attributes) && allow_destroy
+            object.mark_for_destruction if destroy_flag?(attributes) && allow_destroy
           end
 
-          def self.has_destroy_flag?(hash)
+          def self.destroy_flag?(hash)
             ActiveData.typecaster(Boolean).call(hash[DESTROY_ATTRIBUTE])
           end
 
-          def self.reject_new_object?(object, association_name, attributes)
-            has_destroy_flag?(attributes) || call_reject_if(object, association_name, attributes)
+          def self.reject_new_object?(object, association_name, attributes, options)
+            options[:update_only] || destroy_flag?(attributes) || call_reject_if(object, association_name, attributes)
           end
 
           def self.call_reject_if(object, association_name, attributes)
-            return false if has_destroy_flag?(attributes)
+            return false if destroy_flag?(attributes)
             case callback = object.nested_attributes_options[association_name][:reject_if]
             when Symbol
-              method(callback).arity == 0 ? send(callback) : send(callback, attributes)
+              method(callback).arity.zero? ? send(callback) : send(callback, attributes)
             when Proc
               callback.call(attributes)
             end
@@ -174,6 +191,21 @@ module ActiveData
             NestedAttributesMethods.accepts_nested_attributes_for self, *attr_names
           end
         end
+
+        module NestedAttributesMethodsExtension
+          def self.ensure_extended!(klass)
+            return if klass.singleton_class.ancestors.include?(self)
+            klass.extend(self)
+          end
+
+          def nested_attributes_methods_module
+            @nested_attributes_methods_module ||= begin
+              mod = const_set(:NestedAttributesMethods, Module.new)
+              include(mod)
+              mod
+            end
+          end
+        end
       end
     end
   end

data/lib/active_data/model/associations/persistence_adapters/active_record/referenced_proxy.rb

@@ -0,0 +1,31 @@
+module ActiveData
+  module Model
+    module Associations
+      module PersistenceAdapters
+        class ActiveRecord < Base
+          class ReferencedProxy < ActiveData::Model::Associations::Collection::Proxy
+            # You can't create data directly through ActiveRecord::Relation
+            METHODS_EXCLUDED_FROM_DELEGATION = %w[build create create!].map(&:to_sym).freeze
+
+            attr_reader :association
+            delegate :scope, to: :@association
+
+            def method_missing(method, *args, &block)
+              delegate_to_scope?(method) ? scope.send(method, *args, &block) : super
+            end
+
+            def respond_to_missing?(method, include_private = false)
+              delegate_to_scope?(method) || super
+            end
+
+          private
+
+            def delegate_to_scope?(method)
+              METHODS_EXCLUDED_FROM_DELEGATION.exclude?(method) && scope.respond_to?(method)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/persistence_adapters/active_record.rb

@@ -0,0 +1,66 @@
+require 'active_data/model/associations/persistence_adapters/active_record/referenced_proxy'
+
+module ActiveData
+  module Model
+    module Associations
+      module PersistenceAdapters
+        class ActiveRecord < Base
+          TYPES = {
+            integer: Integer,
+            float: Float,
+            decimal: BigDecimal,
+            datetime: Time,
+            timestamp: Time,
+            time: Time,
+            date: Date,
+            text: String,
+            string: String,
+            binary: String,
+            boolean: Boolean
+          }.freeze
+
+          alias_method :data_type, :data_source
+
+          def build(attributes)
+            data_source.new(attributes)
+          end
+
+          def persist(object, raise_error: false)
+            raise_error ? object.save! : object.save
+          end
+
+          def scope(owner, source)
+            scope = data_source.unscoped
+
+            if scope_proc
+              scope = if scope_proc.arity.zero?
+                scope.instance_exec(&scope_proc)
+              else
+                scope.instance_exec(owner, &scope_proc)
+              end
+            end
+
+            scope.where(primary_key => source)
+          end
+
+          def identify(object)
+            object[primary_key] if object
+          end
+
+          def primary_key
+            @primary_key ||= :id
+          end
+
+          def primary_key_type
+            column = data_source.columns_hash[primary_key.to_s]
+            TYPES[column.type]
+          end
+
+          def referenced_proxy(association)
+            ReferencedProxy.new(association)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/persistence_adapters/base.rb

@@ -0,0 +1,53 @@
+module ActiveData
+  module Model
+    module Associations
+      module PersistenceAdapters
+        class Base
+          attr_reader :data_source, :primary_key, :scope_proc
+
+          def initialize(data_source, primary_key, scope_proc = nil)
+            @data_source = data_source
+            @primary_key = primary_key
+            @scope_proc = scope_proc
+          end
+
+          def build(_attributes)
+            raise NotImplementedError, 'Should be implemented in inhereted adapter. Build new instance of data object by attributes'
+          end
+
+          def persist(_object, *)
+            raise NotImplementedError, 'Should be implemented in inhereted adapter. Build new instance of data object by attributes'
+          end
+
+          def scope(_owner, _source)
+            raise NotImplementedError, 'Should be implemented in inhereted adapter. Better to be Enumerable'
+          end
+
+          def find_one(owner, identificator)
+            scope(owner, identificator).first
+          end
+
+          def find_all(owner, identificators)
+            scope(owner, identificators).to_a
+          end
+
+          def identify(_object)
+            raise NotImplementedError, 'Should be implemented in inhereted adapter. Field to be used as primary_key for object'
+          end
+
+          def data_type
+            raise NotImplementedError, 'Should be implemented in inhereted adapter. Type of data object for type_check'
+          end
+
+          def primary_key_type
+            raise NotImplementedError, 'Should be implemented in inhereted adapter. Ruby data type'
+          end
+
+          def referenced_proxy
+            raise NotImplementedError, 'Should be implemented in inhereted adapter. Object to manage proxying of methods to scope.'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/references_any.rb

@@ -0,0 +1,41 @@
+module ActiveData
+  module Model
+    module Associations
+      class ReferencesAny < Base
+        def scope(source = read_source)
+          reflection.persistence_adapter.scope(owner, source)
+        end
+
+      private
+
+        def read_source
+          attribute.read_before_type_cast
+        end
+
+        def write_source(value)
+          attribute.write_value value
+        end
+
+        def attribute
+          @attribute ||= owner.attribute(reflection.reference_key)
+        end
+
+        def build_object(attributes)
+          reflection.persistence_adapter.build(attributes)
+        end
+
+        def persist_object(object, **options)
+          reflection.persistence_adapter.persist(object, **options)
+        end
+
+        def matches_type?(object)
+          object.is_a?(reflection.persistence_adapter.data_type)
+        end
+
+        def raise_type_mismatch(object)
+          raise AssociationTypeMismatch.new(reflection.persistence_adapter.data_type, object.class)
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/references_many.rb

@@ -1,50 +1,71 @@
 module ActiveData
   module Model
     module Associations
-      class ReferencesMany < Base
+      class ReferencesMany < ReferencesAny
+        def build(attributes = {})
+          append([build_object(attributes)]).last
+        end
+
+        def create(attributes = {})
+          object = build(attributes)
+          persist_object(object)
+          object
+        end
+
+        def create!(attributes = {})
+          object = build(attributes)
+          persist_object(object, raise_error: true)
+          object
+        end
+
         def apply_changes
-          present_keys = target.reject { |t| t.marked_for_destruction? }.map(&reflection.primary_key).compact
-          write_source(present_keys)
-          true
+          target.all? do |object|
+            if object
+              if object.marked_for_destruction? && reflection.autosave?
+                object.destroy
+              elsif object.new_record? || (reflection.autosave? && object.changed?)
+                persist_object(object)
+              else
+                true
+              end
+            else
+              true
+            end
+          end
         end
 
-        def target= object
+        def target=(object)
           loaded!
           @target = object.to_a
         end
 
         def load_target
           source = read_source
-          source.present? ? scope(source).to_a : default
+          source.present? ? reflection.persistence_adapter.find_all(owner, source) : default
         end
 
         def default
-          unless evar_loaded?
-            default = Array.wrap(reflection.default(owner))
-            if default.all? { |object| object.is_a?(reflection.klass) }
-              default
-            elsif default.all? { |object| object.is_a?(Hash) }
-              default.map { |attributes| reflection.klass.new(attributes) }
-            else
-              scope(default).to_a
-            end if default.present?
-          end || []
-        end
+          return [] if evar_loaded?
 
-        def read_source
-          attribute.read_before_type_cast
-        end
+          default = Array.wrap(reflection.default(owner))
 
-        def write_source value
-          attribute.write_value value
+          return [] unless default
+
+          if default.all? { |object| object.is_a?(reflection.persistence_adapter.data_type) }
+            default
+          elsif default.all? { |object| object.is_a?(Hash) }
+            default.map { |attributes| build_object(attributes) }
+          else
+            reflection.persistence_adapter.find_all(owner, default)
+          end || []
         end
 
-        def reader force_reload = false
+        def reader(force_reload = false)
           reload if force_reload
-          @proxy ||= Collection::Referenced.new self
+          @proxy ||= reflection.persistence_adapter.referenced_proxy(self)
         end
 
-        def replace objects
+        def replace(objects)
           loaded!
           transaction do
             clear
@@ -65,31 +86,24 @@ module ActiveData
           reload.empty?
         end
 
-        def scope source = read_source
-          reflection.scope.where(reflection.primary_key => source)
-        end
-
         def identify
-          target.map(&reflection.primary_key)
+          target.map { |obj| reflection.persistence_adapter.identify(obj) }
         end
 
       private
 
-        def append objects
+        def append(objects)
           attribute.pollute do
             objects.each do |object|
               next if target.include?(object)
-              raise AssociationTypeMismatch.new(reflection.klass, object.class) unless object.is_a?(reflection.klass)
+              raise_type_mismatch(object) unless matches_type?(object)
+
               target.push(object)
-              apply_changes!
+              write_source(identify)
             end
           end
           target
         end
-
-        def attribute
-          @attribute ||= owner.attribute(reflection.reference_key)
-        end
       end
     end
   end

data/lib/active_data/model/associations/references_one.rb

@@ -1,62 +1,74 @@
 module ActiveData
   module Model
     module Associations
-      class ReferencesOne < Base
+      class ReferencesOne < ReferencesAny
+        def build(attributes = {})
+          replace(build_object(attributes))
+        end
+
+        def create(attributes = {})
+          persist_object(build(attributes))
+          target
+        end
+
+        def create!(attributes = {})
+          persist_object(build(attributes), raise_error: true)
+          target
+        end
+
         def apply_changes
-          if target && !target.marked_for_destruction?
-            write_source identify
+          if target
+            if target.marked_for_destruction? && reflection.autosave?
+              target.destroy
+            elsif target.new_record? || (reflection.autosave? && target.changed?)
+              persist_object(target)
+            else
+              true
+            end
           else
-            write_source nil
+            true
           end
-          true
         end
 
-        def target= object
+        def target=(object)
           loaded!
           @target = object
         end
 
         def load_target
           source = read_source
-          source ? scope(source).first : default
+          source ? reflection.persistence_adapter.find_one(owner, source) : default
         end
 
         def default
-          unless evar_loaded?
-            default = reflection.default(owner)
-            case default
-            when reflection.klass
-              default
-            when Hash
-              reflection.klass.new(default)
-            else
-              scope(default).first
-            end if default
-          end
-        end
+          return if evar_loaded?
 
-        def read_source
-          attribute.read_before_type_cast
-        end
+          default = reflection.default(owner)
+
+          return unless default
 
-        def write_source value
-          attribute.write_value value
+          case default
+          when reflection.persistence_adapter.data_type
+            default
+          when Hash
+            build_object(default)
+          else
+            reflection.persistence_adapter.find_one(owner, default)
+          end
         end
 
-        def reader force_reload = false
+        def reader(force_reload = false)
           reset if force_reload
           target
         end
 
-        def replace object
-          unless object.nil? || object.is_a?(reflection.klass)
-            raise AssociationTypeMismatch.new(reflection.klass, object.class)
-          end
+        def replace(object)
+          raise_type_mismatch(object) unless object.nil? || matches_type?(object)
 
           transaction do
             attribute.pollute do
               self.target = object
-              apply_changes!
+              write_source identify
             end
           end
 
@@ -64,18 +76,8 @@ module ActiveData
         end
         alias_method :writer, :replace
 
-        def scope source = read_source
-          reflection.scope.where(reflection.primary_key => source)
-        end
-
         def identify
-          target.try(reflection.primary_key)
-        end
-
-      private
-
-        def attribute
-          @attribute ||= owner.attribute(reflection.reference_key)
+          reflection.persistence_adapter.identify(target)
         end
       end
     end