granite-form 0.1.0

data/lib/granite/form/model/associations/nested_attributes.rb

@@ -0,0 +1,215 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        module NestedAttributes
+          extend ActiveSupport::Concern
+
+          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.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|
+                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)
+                  Granite::Form::Model::Associations::NestedAttributes::NestedAttributesMethods
+                    .assign_nested_attributes_for_#{type}_association(self, :#{association_name}, attributes)
+                end
+                METHOD
+              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 Granite::Form::ObjectNotFound.new(object, association_name, attributes[primary_attribute_name])
+              elsif !reject_new_object?(object, association_name, attributes, options)
+                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 Granite::Form::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?
+                  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)
+                      .typecast(attributes[primary_attribute_name])
+                    record.primary_attribute == primary_attribute_value
+                  end
+                  if existing_record
+                    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
+                    end
+                  else
+                    raise Granite::Form::ObjectNotFound.new(object, association_name, attributes[primary_attribute_name])
+                  end
+                end
+              end
+            end
+
+            def self.check_record_limit!(limit, attributes_collection)
+              limit = case limit
+              when Symbol
+                send(limit)
+              when Proc
+                limit.call
+              else
+                limit
+              end
+
+              return unless limit && attributes_collection.size > limit
+
+              raise Granite::Form::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 destroy_flag?(attributes) && allow_destroy
+            end
+
+            def self.destroy_flag?(hash)
+              Granite::Form.typecaster(Boolean).call(hash[DESTROY_ATTRIBUTE])
+            end
+
+            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 destroy_flag?(attributes)
+              case callback = object.nested_attributes_options[association_name][:reject_if]
+              when Symbol
+                method(callback).arity.zero? ? 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 < Granite::Form::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
+
+          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
+  end
+end

data/lib/granite/form/model/associations/persistence_adapters/active_record/referenced_proxy.rb

@@ -0,0 +1,33 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        module PersistenceAdapters
+          class ActiveRecord < Base
+            class ReferencedProxy < Granite::Form::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
+end

data/lib/granite/form/model/associations/persistence_adapters/active_record.rb

@@ -0,0 +1,68 @@
+require 'granite/form/model/associations/persistence_adapters/active_record/referenced_proxy'
+
+module Granite
+  module Form
+    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
+end

data/lib/granite/form/model/associations/persistence_adapters/base.rb

@@ -0,0 +1,55 @@
+module Granite
+  module Form
+    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
+end

data/lib/granite/form/model/associations/references_any.rb

@@ -0,0 +1,43 @@
+module Granite
+  module Form
+    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
+end

data/lib/granite/form/model/associations/references_many.rb

@@ -0,0 +1,113 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        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
+            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)
+            loaded!
+            @target = object.to_a
+          end
+
+          def load_target
+            source = read_source
+            source.present? ? reflection.persistence_adapter.find_all(owner, source) : default
+          end
+
+          def default
+            return [] if evar_loaded?
+
+            default = Array.wrap(reflection.default(owner))
+
+            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)
+            reload if force_reload
+            @proxy ||= reflection.persistence_adapter.referenced_proxy(self)
+          end
+
+          def replace(objects)
+            loaded!
+            transaction do
+              clear
+              append objects
+            end
+          end
+
+          alias_method :writer, :replace
+
+          def concat(*objects)
+            append objects.flatten
+            reader
+          end
+
+          def clear
+            attribute.pollute do
+              write_source([])
+            end
+            reload.empty?
+          end
+
+          def identify
+            target.map { |obj| reflection.persistence_adapter.identify(obj) }
+          end
+
+        private
+
+          def append(objects)
+            attribute.pollute do
+              objects.each do |object|
+                next if target.include?(object)
+                raise_type_mismatch(object) unless matches_type?(object)
+
+                target.push(object)
+                write_source(identify)
+              end
+            end
+            target
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/associations/references_one.rb

@@ -0,0 +1,88 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        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
+              if target.marked_for_destruction? && reflection.autosave?
+                target.destroy
+              elsif target.new_record? || (reflection.autosave? && target.changed?)
+                persist_object(target)
+              else
+                true
+              end
+            else
+              true
+            end
+          end
+
+          def target=(object)
+            loaded!
+            @target = object
+          end
+
+          def load_target
+            source = read_source
+            source ? reflection.persistence_adapter.find_one(owner, source) : default
+          end
+
+          def default
+            return if evar_loaded?
+
+            default = reflection.default(owner)
+
+            return unless default
+
+            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)
+            reset if force_reload
+            target
+          end
+
+          def replace(object)
+            raise_type_mismatch(object) unless object.nil? || matches_type?(object)
+
+            transaction do
+              attribute.pollute do
+                self.target = object
+                write_source identify
+              end
+            end
+
+            target
+          end
+
+          alias_method :writer, :replace
+
+          def identify
+            reflection.persistence_adapter.identify(target)
+          end
+        end
+      end
+    end
+  end
+end