granite-form 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 848ee19f938a86a22a506585a7a4960bbb192b977fdc61173b05057c0381ec79
-  data.tar.gz: 9c024906d4e6c7c8a93db7bcfe005dbffa956e4239a0078d642b3604c4226c0a
+  metadata.gz: 908865a58fa79739294c85bb506d878596a28782c02a9a2825ca1fb7fd128972
+  data.tar.gz: ff9b6cbed34774e3dedb0b33c28b75694b1575051adb989248ca5695254e9586
 SHA512:
-  metadata.gz: e35f2d05bd0adaabdb00df1799b9997d6f01818f00271ee24cc628b9e5edf859ab4f15e1ee3e56f697485d89a2f1c05ebeff42816f53b4293c82854e3f4e247e
-  data.tar.gz: df23355e592e78a1d998ace8a8010e188360ce99173fe69623bf3b03da18286f3476d509620b89f91fcaa5df299a20b32906cb3c0ae95353b75eb2c694afe409
+  metadata.gz: 92d055b121d30a9644521227782908a0b84ef0847c16ce60fafec47cb17c5c2988e8a071e199ed5506dd0783bba335b6a399a519c095867658e310680dd96f10
+  data.tar.gz: 4b4cf5f23530ad12408f498df6eed11e53438dd0a6f110ae04c10568934f041dbb64b946ee42352b7bfec83119a5827b652c8fddd62e745fa0f2835448674ce6

data/.github/CODEOWNERS

@@ -1 +1 @@
-* @toptal/coresmiths-team
+* @toptal/portals-experience-be

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 # master
 
 ## Next
+## v0.4.0
+
+* [BREAKING] Drop support for taking `model` as first argument in default/readonly/enum/normalize. This means that `default: -> (model) { model.other_field}` is no longer supported and should be replaced with `default: -> { other_field }`.
+* Add support for evaluating `Symbol` for readonly/enum/normalize. If symbol is passed in one of those options, method with that name will be called when evaluating the value.
+* [BREAKING] Remove `localized` attribute type.
+* [BREAKING] Change the behavior of `default` and `normalize` for `collection` & `dictionary`. Instead of acting per element they will now act on the attribute as a whole.
+  * E.g. `collection :numbers, default: [1, 2, 3]` will not set the default for the whole collection of `numbers` rather than each element in `numbers`. 
+
 ## v0.3.0
 
 - [BREAKING] Stop automatically saving `references_one`/`references_many` when applying changes.

data/README.md

@@ -172,9 +172,10 @@ It is possible to provide default values for attributes and they will act in the
 
 ```ruby
 attribute :check, Boolean, default: false # Simply false by default
-attribute :today, Date, default: ->{ Time.zone.now.to_date } # Dynamic default value
-attribute :today_wday, Integer, default: ->{ today.wday } # Default is evaluated in instance context
-attribute :today_wday, Integer, default: ->(instance) { instance.today.wday } # The same as previous, but instance provided explicitly
+attribute :wday, Integer, default: ->{ today.wday } # Default evaluated in instance context
+def calculate_today
+  Time.zone.now.today
+end
 ```
 
 ##### Enums
@@ -201,8 +202,8 @@ attribute :title, String, normalizers: [->(value) { value.strip }, trim: {length
 
 ```ruby
 attribute :name, String, readonly: true # Readonly forever
-attribute :name, String, readonly: -> { true } # Conditionally readonly
-attribute :name, String, readonly: ->(instance) { instance.subject.present? } # Explicit instance
+attribute :name, String, readonly: :name_changed? # Conditional with calling method
+attribute :name, String, readonly: -> { subject.present? } # Conditional with lambda
 ```
 
 #### Collection
@@ -251,14 +252,6 @@ end
 
 The keys list might be restricted with the `:keys` option. Default and enum modifiers are applied on each value, normalizers are applied on the hash.
 
-#### Localized
-
-`localized` is similar to how `Globalize 3` attributes work.
-
-```ruby
-localized :title, String
-```
-
 #### Represents
 
 `represents` provides an easy way to expose model attributes through an interface.

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

@@ -74,7 +74,7 @@ module Granite
               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.type_definition.ensure_type(attributes[primary_attribute_name]) if primary_attribute
+                primary_attribute_value = primary_attribute.type_definition.prepare(attributes[primary_attribute_name]) if primary_attribute
               end
 
               if existing_record && (!primary_attribute || options[:update_only] || existing_record.primary_attribute == primary_attribute_value)
@@ -124,7 +124,7 @@ module Granite
                 else
                   existing_record = association.target.detect do |record|
                     primary_attribute_value = record.attribute(primary_attribute_name)
-                      .type_definition.ensure_type(attributes[primary_attribute_name])
+                      .type_definition.prepare(attributes[primary_attribute_name])
                     record.primary_attribute == primary_attribute_value
                   end
                   if existing_record

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_one.rb

@@ -7,6 +7,8 @@ module Granite
       module Associations
         module Reflections
           class ReferencesOne < ReferencesAny
+            include Singular
+
             def self.build(target, generated_methods, name, *args, &block)
               reflection = super
 

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

@@ -4,20 +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
-                RUBY
-              end
-            end
-
             def collection?
               false
             end

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.negative? ? 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,6 +4,10 @@ module Granite
       module Attributes
         module Reflections
           class Attribute < Base
+            def self.attribute_class
+              Granite::Form::Model::Attributes::Attribute
+            end
+
             def self.generate_methods(name, target)
               target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{name}
@@ -40,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

@@ -28,24 +28,26 @@ module Granite
             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/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

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

@@ -1,5 +1,6 @@
 require 'active_model/version'
 require 'granite/form/model/attributes/reflections/represents'
+require 'granite/form/model/attributes/reflections/represents/build_type_definition'
 require 'granite/form/model/attributes/represents'
 
 module Granite

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

@@ -12,6 +12,12 @@ module Granite
           alias_method :validate, :valid?
         end
 
+        class_methods do
+          def validates_presence?(attr)
+            _validators[attr.to_sym].grep(ActiveModel::Validations::PresenceValidator).present?
+          end
+        end
+
         def validate!(context = nil)
           valid?(context) || raise_validation_error
         end