granite-form 0.2.0 → 0.4.0

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

@@ -3,34 +3,6 @@ module Granite
     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

data/lib/granite/form/model/associations/reflections/embeds_any.rb

@@ -22,7 +22,7 @@ module Granite
                 Class.new(superclass || Granite::Form.base_class) do
                   include Granite::Form::Model
                   include Granite::Form::Model::Associations
-                  include Granite::Form::Model::Lifecycle
+                  include Granite::Form::Model::Persistence
                   include Granite::Form::Model::Primary
                   include Granite::Form.base_concern if Granite::Form.base_concern
                 end

data/lib/granite/form/model/associations/reflections/embeds_many.rb

@@ -5,7 +5,7 @@ module Granite
         module Reflections
           class EmbedsMany < EmbedsAny
             def self.build(target, generated_methods, name, options = {}, &block)
-              target.add_attribute(Granite::Form::Model::Attributes::Reflections::Base, name) if target < Granite::Form::Model::Attributes
+              target.add_attribute(Granite::Form::Model::Attributes::Reflections::Base, name, type: Object) if target < Granite::Form::Model::Attributes
               options[:validate] = true unless options.key?(:validate)
               super
             end

data/lib/granite/form/model/associations/reflections/embeds_one.rb

@@ -7,10 +7,20 @@ module Granite
             include Singular
 
             def self.build(target, generated_methods, name, options = {}, &block)
-              target.add_attribute(Granite::Form::Model::Attributes::Reflections::Base, name) if target < Granite::Form::Model::Attributes
+              target.add_attribute(Granite::Form::Model::Attributes::Reflections::Base, name, type: Object) if target < Granite::Form::Model::Attributes
               options[:validate] = true unless options.key?(:validate)
               super
             end
+
+            def self.generate_methods(name, target)
+              super
+
+              target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def build_#{name} attributes = {}
+                  association(:#{name}).build(attributes)
+                end
+              RUBY
+            end
           end
         end
       end

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

@@ -53,10 +53,6 @@ module Granite
             def inspect
               "#{self.class.name.demodulize}(#{persistence_adapter.data_type})"
             end
-
-            def autosave?
-              !!options[:autosave]
-            end
           end
         end
       end

data/lib/granite/form/model/associations/reflections/singular.rb

@@ -4,28 +4,6 @@ module Granite
       module Associations
         module Reflections
           module Singular
-            extend ActiveSupport::Concern
-
-            module ClassMethods
-              def generate_methods(name, target)
-                super
-
-                target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def build_#{name} attributes = {}
-                  association(:#{name}).build(attributes)
-                end
-
-                def create_#{name} attributes = {}
-                  association(:#{name}).create(attributes)
-                end
-
-                def create_#{name}! attributes = {}
-                  association(:#{name}).create!(attributes)
-                end
-                RUBY
-              end
-            end
-
             def collection?
               false
             end

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

@@ -100,12 +100,6 @@ module Granite
           (@_associations ||= {})[reflection.name] ||= reflection.build_association(self)
         end
 
-        def apply_association_changes!
-          association_names.all? do |name|
-            association(name).apply_changes!
-          end
-        end
-
       private
 
         def attributes_for_inspect

data/lib/granite/form/model/attributes/attribute.rb

@@ -14,7 +14,7 @@ module Granite
 
           def read
             variable_cache(:value) do
-              normalize(enumerize(type_definition.ensure_type(read_before_type_cast)))
+              normalize(type_definition.prepare(read_before_type_cast))
             end
           end
 
@@ -25,31 +25,13 @@ module Granite
           end
 
           def default
-            defaultizer.is_a?(Proc) ? evaluate(&defaultizer) : defaultizer
+            owner.evaluate_if_proc(defaultizer)
           end
 
           def defaultize(value, default_value = nil)
             !defaultizer.nil? && value.nil? ? default_value || default : value
           end
 
-          def enum
-            source = enumerizer.is_a?(Proc) ? evaluate(&enumerizer) : enumerizer
-
-            case source
-            when Range
-              source.to_a
-            when Set
-              source
-            else
-              Array.wrap(source)
-            end.to_set
-          end
-
-          def enumerize(value)
-            set = enum if enumerizer
-            value if !set || (set.none? || set.include?(value))
-          end
-
           def normalize(value)
             if normalizers.none?
               value
@@ -57,7 +39,7 @@ module Granite
               normalizers.inject(value) do |val, normalizer|
                 case normalizer
                 when Proc
-                  evaluate(val, &normalizer)
+                  owner.evaluate(normalizer, val)
                 when Hash
                   normalizer.inject(val) do |v, (name, options)|
                     Granite::Form.normalizer(name).call(v, options, self)

data/lib/granite/form/model/attributes/base.rb

@@ -3,13 +3,12 @@ module Granite
     module Model
       module Attributes
         class Base
-          attr_reader :owner, :reflection
+          attr_reader :type_definition
+          delegate :type, :reflection, :owner, :enum, to: :type_definition
           delegate :name, :readonly, to: :reflection
-          delegate :type, to: :type_definition
 
-          def initialize(reflection, owner)
-            @reflection = reflection
-            @owner = owner
+          def initialize(type_definition)
+            @type_definition = type_definition
             @origin = :default
           end
 
@@ -53,11 +52,7 @@ module Granite
           end
 
           def readonly?
-            !!(readonly.is_a?(Proc) ? evaluate(&readonly) : readonly)
-          end
-
-          def type_definition
-            @type_definition ||= build_type_definition(reflection.type)
+            !!owner.evaluate(readonly)
           end
 
           def inspect_attribute
@@ -96,19 +91,6 @@ module Granite
 
         private
 
-          def build_type_definition(type)
-            Granite::Form.type_for(type).new(type, reflection, owner)
-          end
-
-          def evaluate(*args, &block)
-            if block.arity >= 0 && block.arity <= args.length
-              owner.instance_exec(*args.first(block.arity), &block)
-            else
-              args = block.arity < 0 ? args : args.first(block.arity)
-              yield(*args, owner)
-            end
-          end
-
           def remove_variable(*names)
             names.flatten.each do |name|
               name = :"@#{name}"

data/lib/granite/form/model/attributes/reference_many.rb

@@ -5,7 +5,7 @@ module Granite
         class ReferenceMany < ReferenceOne
           def type_casted_value
             variable_cache(:value) do
-              read_before_type_cast.map { |id| type_definition.ensure_type(id) }
+              read_before_type_cast.map { |id| type_definition.prepare(id) }
             end
           end
 

data/lib/granite/form/model/attributes/reference_one.rb

@@ -24,7 +24,7 @@ module Granite
 
           def type_casted_value
             variable_cache(:value) do
-              type_definition.ensure_type(read_before_type_cast)
+              type_definition.prepare(read_before_type_cast)
             end
           end
 

data/lib/granite/form/model/attributes/reflections/attribute.rb

@@ -4,10 +4,8 @@ module Granite
       module Attributes
         module Reflections
           class Attribute < Base
-            def self.build(target, generated_methods, name, *args, &block)
-              attribute = super(target, generated_methods, name, *args, &block)
-              generate_methods name, generated_methods
-              attribute
+            def self.attribute_class
+              Granite::Form::Model::Attributes::Attribute
             end
 
             def self.generate_methods(name, target)
@@ -46,10 +44,6 @@ module Granite
               @defaultizer ||= options[:default]
             end
 
-            def enumerizer
-              @enumerizer ||= options[:enum] || options[:in]
-            end
-
             def normalizers
               @normalizers ||= Array.wrap(options[:normalize] || options[:normalizer] || options[:normalizers])
             end

data/lib/granite/form/model/attributes/reflections/base/build_type_definition.rb

@@ -0,0 +1,38 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        module Reflections
+          class Base
+            class BuildTypeDefinition
+              attr_reader :owner, :reflection
+              delegate :name, to: :reflection
+
+              def initialize(owner, reflection)
+                @owner = owner
+                @reflection = reflection
+              end
+
+              def call
+                raise "Type is not specified for `#{name}`" if type.nil?
+
+                type_definition_for(type)
+              end
+
+            private
+
+              def type
+                reflection.options[:type]
+              end
+
+              def type_definition_for(type)
+                type = type.to_s.camelize.constantize unless type.is_a?(Module)
+                Granite::Form.type_for(type).new(type, reflection, owner)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/attributes/reflections/base.rb

@@ -7,11 +7,9 @@ module Granite
             attr_reader :name, :options
 
             class << self
-              def build(_target, _generated_methods, name, *args, &block)
-                options = args.extract_options!
-                options[:type] = args.first if args.first
-                options[:default] = block if block
-                new(name, options)
+              def build(_target, generated_methods, name, *args, &block)
+                generate_methods name, generated_methods
+                new(name, *args, &block)
               end
 
               def generate_methods(name, target) end
@@ -21,30 +19,35 @@ module Granite
               end
             end
 
-            def initialize(name, options = {})
+            def initialize(name, *args, &block)
               @name = name.to_s
-              @options = options
+
+              @options = args.extract_options!
+              @options[:type] = args.first if args.first
+              @options[:default] = block if block
             end
 
             def build_attribute(owner, raw_value = Granite::Form::UNDEFINED)
-              attribute = self.class.attribute_class.new(self, owner)
+              type_definition = self.class::BuildTypeDefinition.new(owner, self).call
+              attribute = self.class.attribute_class.new(type_definition)
               attribute.write_value(raw_value, origin: :persistence) unless raw_value == Granite::Form::UNDEFINED
               attribute
             end
 
             def type
-              @type ||= case options[:type]
-              when Class, Module
-                options[:type]
-              when nil
-                raise "Type is not specified for `#{name}`"
-              else
-                options[:type].to_s.camelize.constantize
-              end
+              options[:type]
             end
 
             def readonly
-              @readonly ||= options[:readonly]
+              options[:readonly]
+            end
+
+            def enum
+              options[:enum] || options[:in]
+            end
+
+            def keys
+              @keys ||= Array.wrap(options[:keys]).map(&:to_s)
             end
 
             def inspect_reflection

data/lib/granite/form/model/attributes/reflections/collection/build_type_definition.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Granite
+  module Form
+    module Model
+      module Attributes
+        module Reflections
+          class Collection
+            class BuildTypeDefinition < Base::BuildTypeDefinition
+              def call
+                Types::Collection.new(super)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/attributes/reflections/dictionary/build_type_definition.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Granite
+  module Form
+    module Model
+      module Attributes
+        module Reflections
+          class Dictionary
+            class BuildTypeDefinition < Base::BuildTypeDefinition
+              def call
+                Types::Dictionary.new(super)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/attributes/reflections/dictionary.rb

@@ -4,9 +4,6 @@ module Granite
       module Attributes
         module Reflections
           class Dictionary < Attribute
-            def keys
-              @keys ||= Array.wrap(options[:keys]).map(&:to_s)
-            end
           end
         end
       end

data/lib/granite/form/model/attributes/reflections/reference_one.rb

@@ -4,12 +4,6 @@ module Granite
       module Attributes
         module Reflections
           class ReferenceOne < Base
-            def self.build(_target, generated_methods, name, *args)
-              options = args.extract_options!
-              generate_methods name, generated_methods
-              new(name, options)
-            end
-
             def self.generate_methods(name, target)
               target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{name}

data/lib/granite/form/model/attributes/reflections/represents/build_type_definition.rb

@@ -0,0 +1,73 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        module Reflections
+          class Represents
+            class BuildTypeDefinition < Base::BuildTypeDefinition
+              GRANITE_COLLECTION_TYPES = [Granite::Form::Model::Attributes::ReferenceMany].freeze
+              TYPES = {
+                'ActiveRecord::Enum::EnumType' => String,
+                'ActiveRecord::Type::Serialized' => Object
+              }.freeze
+
+              def call
+                if type.present?
+                  super
+                else
+                  granite_form_type || active_record_type || type_definition_for(Object)
+                end
+              end
+
+            private
+
+              def reference
+                owner.__send__(reflection.reference)
+              end
+
+              def granite_form_type
+                return nil unless reference.is_a?(Model)
+
+                reference_attribute = reference.attribute(name)
+                return nil if reference_attribute.nil?
+
+                type_definition = reference_attribute.type_definition.build_duplicate(reflection, owner)
+                if GRANITE_COLLECTION_TYPES.any? { |klass| reference_attribute.is_a? klass }
+                  Types::Collection.new(type_definition)
+                else
+                  type_definition
+                end
+              end
+
+              def active_record_type
+                return nil unless reference.respond_to?(:type_for_attribute)
+
+                attribute_type = reference.type_for_attribute(active_model_attribute_name.to_s)
+
+                attribute_type_name = attribute_type.class.to_s
+                if TYPES.key?(attribute_type_name)
+                  type_definition_for(TYPES[attribute_type_name])
+                elsif attribute_type.respond_to?(:subtype)
+                  Types::Collection.new(convert_active_model_type_to_definition(attribute_type.subtype))
+                else
+                  convert_active_model_type_to_definition(attribute_type)
+                end
+              end
+
+              def active_model_attribute_name
+                aliases = reference.class.try(:attribute_aliases) || {}
+                aliases.fetch(name.to_s, name)
+              end
+
+              def convert_active_model_type_to_definition(attribute_type)
+                type = attribute_type.try(:value_class) ||
+                  Associations::PersistenceAdapters::ActiveRecord::TYPES[attribute_type.type&.to_sym]
+                type_definition_for(type) if type
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/attributes/reflections/represents.rb

@@ -4,14 +4,22 @@ module Granite
       module Attributes
         module Reflections
           class Represents < Attribute
+            def self.attribute_class
+              Attributes::Represents
+            end
+
             def self.build(target, generated_methods, name, *args, &block)
               options = args.extract_options!
 
               reference = target.reflect_on_association(options[:of]) if target.respond_to?(:reflect_on_association)
               reference ||= target.reflect_on_attribute(options[:of]) if target.respond_to?(:reflect_on_attribute)
               options[:of] = reference.name if reference
-              validates_nested = target.respond_to?(:validates_nested) && !target.validates_nested?(options[:of])
-              target.validates_nested(options[:of]) if validates_nested
+
+              if options.fetch(:validate_reference, true)
+                validates_nested = target.respond_to?(:validates_nested) && !target.validates_nested?(options[:of])
+                target.validates_nested(options[:of]) if validates_nested
+                target.validates_presence_of(options[:of]) unless target.validates_presence?(options[:of])
+              end
 
               super(target, generated_methods, name, *args, options, &block)
             end

data/lib/granite/form/model/attributes/represents.rb

@@ -5,60 +5,45 @@ module Granite
         class Represents < Attribute
           delegate :reader, :reader_before_type_cast, :writer, to: :reflection
 
-          def write(value)
-            return if readonly?
-            pollute do
-              reset
-              reference.send(writer, value)
-            end
-          end
-
-          def reset
+          def initialize(*_args)
             super
-            remove_variable(:cached_value, :cached_value_before_type_cast)
+
+            set_default_value
+            set_default_value_before_type_cast
           end
 
-          def read
-            reset if cached_value != read_value
-            variable_cache(:value) do
-              normalize(enumerize(defaultize(cached_value, read_before_type_cast)))
-            end
+          def sync
+            reference.public_send(writer, read) if reference.respond_to?(writer)
           end
 
-          def read_before_type_cast
-            reset if cached_value_before_type_cast != read_value_before_type_cast
-            variable_cache(:value_before_type_cast) do
-              defaultize(cached_value_before_type_cast)
+          def changed?
+            if reflection.options.key?(:default)
+              reference.public_send(reader) != read
+            else
+              owner.public_send("#{name}_changed?")
             end
           end
 
         private
 
           def reference
-            owner.send(reflection.reference)
+            owner.__send__(reflection.reference)
           end
 
-          def read_value
-            ref = reference
-            ref.public_send(reader) if ref
-          end
-
-          def cached_value
-            variable_cache(:cached_value) { read_value }
-          end
+          def set_default_value
+            return unless reference.respond_to?(reader)
 
-          def read_value_before_type_cast
-            ref = reference
-            return unless ref
-            if ref.respond_to?(reader_before_type_cast)
-              ref.public_send(reader_before_type_cast)
-            else
-              ref.public_send(reader)
+            variable_cache(:value) do
+              normalize(type_definition.prepare(defaultize(reference.public_send(reader))))
             end
           end
 
-          def cached_value_before_type_cast
-            variable_cache(:cached_value_before_type_cast) { read_value_before_type_cast }
+          def set_default_value_before_type_cast
+            return unless reference.respond_to?(reader_before_type_cast)
+
+            variable_cache(:value_before_type_cast) do
+              defaultize(reference.public_send(reader_before_type_cast))
+            end
           end
         end
       end

data/lib/granite/form/model/attributes.rb

@@ -1,12 +1,13 @@
 require 'granite/form/model/attributes/reflections/base'
+require 'granite/form/model/attributes/reflections/base/build_type_definition'
 require 'granite/form/model/attributes/reflections/attribute'
 require 'granite/form/model/attributes/reflections/collection'
+require 'granite/form/model/attributes/reflections/collection/build_type_definition'
 require 'granite/form/model/attributes/reflections/dictionary'
+require 'granite/form/model/attributes/reflections/dictionary/build_type_definition'
 
 require 'granite/form/model/attributes/base'
 require 'granite/form/model/attributes/attribute'
-require 'granite/form/model/attributes/collection'
-require 'granite/form/model/attributes/dictionary'
 
 module Granite
   module Form
@@ -178,6 +179,13 @@ module Granite
 
         alias_method :attributes=, :assign_attributes
 
+        def sync_attributes
+          attribute_names.each do |name|
+            attr = attribute(name)
+            attr.try(:sync) if attr.try(:changed?)
+          end
+        end
+
         def inspect
           "#<#{self.class.send(:original_inspect)} #{attributes_for_inspect.presence || '(no attributes)'}>"
         end