active_data 0.3.0 → 1.0.0

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

@@ -0,0 +1,79 @@
+module ActiveData
+  module Model
+    module Associations
+      class Base
+        attr_accessor :owner, :reflection
+        delegate :macro, :collection?, to: :reflection
+
+        def initialize owner, reflection
+          @owner, @reflection = owner, reflection
+          @evar_loaded = owner.persisted?
+          reset
+        end
+
+        def reset
+          @loaded = false
+          @target = nil
+        end
+
+        def evar_loaded?
+          !!@evar_loaded
+        end
+
+        def loaded?
+          !!@loaded
+        end
+
+        def loaded!
+          @evar_loaded = true
+          @loaded = true
+        end
+
+        def target
+          return @target if loaded?
+          self.target = load_target
+        end
+
+        def reload
+          reset
+          target
+        end
+
+        def apply_changes!
+          apply_changes or raise ActiveData::AssociationChangesNotApplied
+        end
+
+        def transaction &block
+          data = Marshal.load(Marshal.dump(read_source))
+          block.call
+        rescue StandardError => e
+          write_source data
+          reload
+          raise e
+        end
+
+        def inspect
+          "#<#{reflection.macro.to_s.camelize} #{target.inspect.truncate(50, omission: collection? ? '...]' : '...')}>"
+        end
+
+      private
+
+        def read_source
+          reflection.read_source owner
+        end
+
+        def write_source value
+          reflection.write_source owner, value
+        end
+
+        def target_for_inspect
+          if value.length > 50
+            "#{value[0..50]}...".inspect
+          else
+            value.inspect
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/collection/embedded.rb

@@ -0,0 +1,12 @@
+module ActiveData
+  module Model
+    module Associations
+      module Collection
+        class Embedded < Proxy
+          delegate :build, :create, :create!, to: :@association
+          alias_method :new, :build
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/collection/proxy.rb

@@ -0,0 +1,32 @@
+module ActiveData
+  module Model
+    module Associations
+      module Collection
+        class Proxy
+          include Enumerable
+
+          delegate :target, :save, :save!, :loaded?, :reload, :clear, :concat, to: :@association
+          delegate :each, :size, :length, :first, :last, :empty?, :many?, :==, :dup, to: :target
+          alias_method :<<, :concat
+          alias_method :push, :concat
+
+          def initialize(association)
+            @association = association
+          end
+
+          def to_ary
+            dup
+          end
+          alias_method :to_a, :to_ary
+
+          def inspect
+            entries = target.take(10).map!(&:inspect)
+            entries[10] = '...' if target.size > 10
+
+            "#<#{self.class.name.demodulize} [#{entries.join(', ')}]>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/collection/referenced.rb

@@ -0,0 +1,26 @@
+module ActiveData
+  module Model
+    module Associations
+      module Collection
+        class Referenced < Proxy
+          METHODS_EXCLUDED_FROM_DELEGATION = %w[build create create!].map(&:to_sym).freeze
+          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

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

@@ -1,33 +1,139 @@
 module ActiveData
   module Model
     module Associations
-      class EmbedsMany < Association
+      class EmbedsMany < Base
+        def build attributes = {}
+          push_object(reflection.klass.new(attributes))
+        end
+
+        def create attributes = {}
+          build(attributes).tap(&:save)
+        end
+
+        def create! attributes = {}
+          build(attributes).tap(&:save!)
+        end
+
+        def destroyed
+          @destroyed ||= []
+        end
+
+        def apply_changes
+          result = target.map do |object|
+            object.destroyed? || object.marked_for_destruction? ? object.destroy : object.save
+          end.all?
+          @destroyed = target.select(&:destroyed?)
+          target.delete_if(&:destroyed?)
+          result
+        end
 
-        def collection?
-          true
+        def target= objects
+          objects.each { |object| setup_performers! object }
+          loaded!
+          @target = objects
         end
 
-        def define_reader target
-          target.class_eval <<-EOS
-            def #{name}
-              @#{name} ||= begin
-                association = self.class.reflect_on_association('#{name}')
-                association.klass.collection
+        def load_target
+          source = read_source
+          source.present? ? reflection.klass.instantiate_collection(source) : default
+        end
+
+        def default
+          unless evar_loaded?
+            default = Array.wrap(reflection.default(owner))
+            if default.present?
+              collection = if default.all? { |object| object.is_a?(reflection.klass) }
+                default
+              else
+                default.map do |attributes|
+                  reflection.klass.with_sanitize(false) do
+                    reflection.klass.new(attributes)
+                  end
+                end
               end
+              collection.map { |object| object.send(:clear_changes_information) } if reflection.klass.dirty?
+              collection
             end
-          EOS
+          end || []
         end
 
-        def define_writer target
-          target.class_eval <<-EOS
-            def #{name}= value
-              association = self.class.reflect_on_association('#{name}')
-              @#{name} = association.klass.collection(value)
-            end
-          EOS
+        def reset
+          super
+          @target = []
+        end
+
+        def clear
+          transaction { target.all?(&:destroy!) } rescue ActiveData::ObjectNotDestroyed
+          reload.empty?
+        end
+
+        def reader force_reload = false
+          reload if force_reload
+          @proxy ||= Collection::Embedded.new self
+        end
+
+        def replace objects
+          transaction do
+            clear
+            append(objects) or raise ActiveData::AssociationChangesNotApplied
+          end
+        end
+        alias_method :writer, :replace
+
+        def concat *objects
+          append objects.flatten
         end
 
+      private
+
+        def read_source
+          super || []
+        end
+
+        def append objects
+          objects.each do |object|
+            raise AssociationTypeMismatch.new(reflection.klass, object.class) unless object && object.is_a?(reflection.klass)
+            push_object object
+          end
+          result = owner.persisted? ? apply_changes : true
+          result && target
+        end
+
+        def push_object object
+          setup_performers! object
+          target[target.size] = object
+        end
+
+        def setup_performers! object
+          association = self
+
+          object.define_create do
+            source = association.send(:read_source)
+            index = association.target.select do |one|
+              one.persisted? || one === self
+            end.index { |one| one === self }
+
+            source.insert(index, attributes)
+            association.send(:write_source, source)
+          end
+
+          object.define_update do
+            source = association.send(:read_source)
+            index = association.target.select(&:persisted?).index { |one| one === self }
+
+            source[index] = attributes
+            association.send(:write_source, source)
+          end
+
+          object.define_destroy do
+            source = association.send(:read_source)
+            index = association.target.select(&:persisted?).index { |one| one === self }
+
+            source.delete_at(index) if index
+            association.send(:write_source, source)
+          end
+        end
       end
     end
   end
-end
+end

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

@@ -1,30 +1,105 @@
 module ActiveData
   module Model
     module Associations
-      class EmbedsOne < Association
+      class EmbedsOne < Base
+        def build attributes = {}
+          self.target = reflection.klass.new(attributes)
+        end
+
+        def create attributes = {}
+          build(attributes).tap(&:save)
+        end
 
-        def collection?
-          false
+        def create! attributes = {}
+          build(attributes).tap(&:save!)
         end
 
-        def define_reader target
-          target.class_eval <<-EOS
-            def #{name}
-              @#{name}
+        def destroyed
+          @destroyed
+        end
+
+        def apply_changes
+          if target
+            if target.destroyed? || target.marked_for_destruction?
+              @destroyed = target
+              clear
+            else
+              target.save
             end
-          EOS
+          else
+            true
+          end
         end
 
-        def define_writer target
-          target.class_eval <<-EOS
-            def #{name}= value
-              association = self.class.reflect_on_association('#{name}')
-              @#{name} = association.klass.instantiate(value) if value
+        def target= object
+          setup_performers! object if object
+          loaded!
+          @target = object
+        end
+
+        def load_target
+          source = read_source
+          source ? reflection.klass.instantiate(source) : default
+        end
+
+        def default
+          unless evar_loaded?
+            default = reflection.default(owner)
+            if default
+              object = if default.is_a?(reflection.klass)
+                default
+              else
+                reflection.klass.with_sanitize(false) do
+                  reflection.klass.new(default)
+                end
+              end
+              object.send(:clear_changes_information) if reflection.klass.dirty?
+              object
             end
-          EOS
+          end
+        end
+
+        def clear
+          target.try(:destroy)
+          reload.nil?
         end
 
+        def reader force_reload = false
+          reload if force_reload
+          target
+        end
+
+        def replace object
+          if object
+            raise AssociationTypeMismatch.new(reflection.klass, object.class) unless object.is_a?(reflection.klass)
+            transaction do
+              clear
+              self.target = object
+              apply_changes! if owner.persisted?
+            end
+          else
+            clear
+          end
+
+          target
+        end
+        alias_method :writer, :replace
+
+      private
+
+        def setup_performers! object
+          association = self
+
+          object.define_save do
+            association.send(:write_source, attributes)
+          end
+
+          object.define_destroy do
+            association.send(:write_source, nil)
+            true
+          end
+        end
       end
     end
   end
-end
+end

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

@@ -0,0 +1,180 @@
+module ActiveData
+  module Model
+    module Associations
+      module NestedAttributes
+        extend ActiveSupport::Concern
+
+        DESTROY_ATTRIBUTE = '_destroy'
+
+        included do
+          class_attribute :nested_attributes_options, instance_writer: false
+          self.nested_attributes_options = {}
+        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.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
+
+            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
+            end
+          end
+
+          def self.assign_nested_attributes_for_one_to_one_association(object, association_name, attributes)
+            options = object.nested_attributes_options[association_name]
+            attributes = attributes.with_indifferent_access
+
+            association = object.association(association_name)
+            existing_record = association.target
+            primary_attribute_name = primary_name_for(association.reflection.klass)
+            if existing_record
+              primary_attribute = existing_record.attribute(primary_attribute_name)
+              primary_attribute_value = primary_attribute.typecast(attributes[primary_attribute_name]) if primary_attribute
+            end
+
+            if existing_record && (!primary_attribute || options[:update_only] || existing_record.primary_attribute == primary_attribute_value)
+              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)
+              assignable_attributes = attributes.except(*unassignable_keys(object))
+
+              if existing_record && !existing_record.persisted?
+                existing_record.assign_attributes(assignable_attributes)
+              else
+                association.build(assignable_attributes)
+              end
+            end
+          end
+
+          def self.assign_nested_attributes_for_collection_association(object, association_name, attributes_collection)
+            options = object.nested_attributes_options[association_name]
+
+            unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
+              raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+            end
+
+            check_record_limit!(options[:limit], attributes_collection)
+
+            association = object.association(association_name)
+            primary_attribute_name = primary_name_for(association.reflection.klass)
+
+            raise ActiveData::UndefinedPrimaryAttribute.new(object.class, association_name) unless primary_attribute_name
+
+            if attributes_collection.is_a? Hash
+              keys = attributes_collection.keys
+              attributes_collection = if keys.include?(primary_attribute_name) || keys.include?(primary_attribute_name.to_sym)
+                [attributes_collection]
+              else
+                attributes_collection.values
+              end
+            end
+
+            attributes_collection.each do |attributes|
+              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
+              else
+                existing_record = association.target.detect do |record|
+                  primary_attribute_value = record.attribute(primary_attribute_name)
+                    .typecast(attributes[primary_attribute_name])
+                  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
+                    end
+                  else
+                    raise ActiveData::ObjectNotFound.new(object, association_name, attributes[primary_attribute_name])
+                  end
+                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
+            end
+          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
+          end
+
+          def self.has_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)
+          end
+
+          def self.call_reject_if(object, association_name, attributes)
+            return false if has_destroy_flag?(attributes)
+            case callback = object.nested_attributes_options[association_name][:reject_if]
+            when Symbol
+              method(callback).arity == 0 ? send(callback) : send(callback, attributes)
+            when Proc
+              callback.call(attributes)
+            end
+          end
+
+          def self.unassignable_keys(object)
+            [primary_name_for(object.class), DESTROY_ATTRIBUTE].compact
+          end
+
+          def self.primary_name_for(klass)
+            klass < ActiveData::Model ? klass.primary_name : 'id'
+          end
+        end
+
+        module ClassMethods
+          def accepts_nested_attributes_for(*attr_names)
+            NestedAttributesMethods.accepts_nested_attributes_for self, *attr_names
+          end
+        end
+      end
+    end
+  end
+end