granite-form 0.1.0

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

@@ -0,0 +1,134 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        class Base
+          attr_reader :name, :owner
+          delegate :type, :typecaster, :readonly, to: :reflection
+
+          def initialize(name, owner)
+            @name = name
+            @owner = owner
+            @origin = :default
+          end
+
+          def reflection
+            @owner.class._attributes[name]
+          end
+
+          def write_value(value, origin: :user)
+            reset
+            @origin = origin
+            @value_cache = value
+          end
+
+          def write(value)
+            return if readonly?
+            write_value value
+          end
+
+          def reset
+            remove_variable(:value, :value_before_type_cast)
+          end
+
+          def read
+            @value_cache
+          end
+
+          def read_before_type_cast
+            @value_cache
+          end
+
+          def came_from_user?
+            @origin == :user
+          end
+
+          def came_from_default?
+            @origin == :default
+          end
+
+          def value_present?
+            !read.nil? && !(read.respond_to?(:empty?) && read.empty?)
+          end
+
+          def query
+            !(read.respond_to?(:zero?) ? read.zero? : read.blank?)
+          end
+
+          def typecast(value)
+            if value.instance_of?(type)
+              value
+            else
+              typecaster.call(value, self) unless value.nil?
+            end
+          end
+
+          def readonly?
+            !!(readonly.is_a?(Proc) ? evaluate(&readonly) : readonly)
+          end
+
+          def inspect_attribute
+            value = case read
+            when Date, Time, DateTime
+              %("#{read.to_s(:db)}")
+            else
+              inspection = read.inspect
+              inspection.size > 100 ? inspection.truncate(50) : inspection
+            end
+            "#{name}: #{value}"
+          end
+
+          def pollute
+            pollute = owner.class.dirty? && !owner.send(:attribute_changed?, name)
+
+            if pollute
+              previous_value = owner.__send__(name)
+              owner.send("#{name}_will_change!")
+
+              result = yield
+
+              owner.__send__(:clear_attribute_changes, [name]) if owner.__send__(name) == previous_value
+
+              if previous_value != read || (
+                read.respond_to?(:changed?) &&
+                  read.changed?
+              )
+                owner.send(:set_attribute_was, name, previous_value)
+              end
+              result
+            else
+              yield
+            end
+          end
+
+        private
+
+          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}"
+              remove_instance_variable(name) if instance_variable_defined?(name)
+            end
+          end
+
+          def variable_cache(name)
+            name = :"@#{name}"
+            if instance_variable_defined?(name)
+              instance_variable_get(name)
+            else
+              instance_variable_set(name, yield)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        class Collection < Attribute
+          def read
+            @value ||= normalize(read_before_type_cast.map do |value|
+              enumerize(typecast(value))
+            end)
+          end
+
+          def read_before_type_cast
+            @value_before_type_cast ||= Array.wrap(@value_cache).map { |value| defaultize(value) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        class Dictionary < Attribute
+          delegate :keys, to: :reflection
+
+          def read
+            @value ||= begin
+                         hash = read_before_type_cast
+                         hash = hash.stringify_keys.slice(*keys) if keys.present?
+
+                         normalize(Hash[hash.map do |key, value|
+                           [key, enumerize(typecast(value))]
+                         end].with_indifferent_access).with_indifferent_access
+                       end
+          end
+
+          def read_before_type_cast
+            @value_before_type_cast ||= Hash[(@value_cache.presence || {}).map do |key, value|
+              [key, defaultize(value)]
+            end].with_indifferent_access
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        class Localized < Attribute
+          def read
+            @value ||= Hash[read_before_type_cast.map do |locale, value|
+              [locale.to_s, normalize(enumerize(typecast(value)))]
+            end]
+          end
+
+          def read_before_type_cast
+            @value_before_type_cast ||= Hash[(@value_cache.presence || {}).map do |locale, value|
+              [locale.to_s, defaultize(value)]
+            end]
+          end
+
+          def write_locale(value, locale)
+            pollute do
+              write(read.merge(locale.to_s => value))
+            end
+          end
+
+          def read_locale(locale)
+            read[owner.class.fallbacks(locale).detect do |fallback|
+              read[fallback.to_s]
+            end.to_s]
+          end
+
+          def read_locale_before_type_cast(locale)
+            read_before_type_cast[owner.class.fallbacks(locale).detect do |fallback|
+              read_before_type_cast[fallback.to_s]
+            end.to_s]
+          end
+
+          def locale_query(locale)
+            value = read_locale(locale)
+            !(value.respond_to?(:zero?) ? value.zero? : value.blank?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        class ReferenceMany < ReferenceOne
+          def type_casted_value
+            variable_cache(:value) do
+              read_before_type_cast.map { |id| typecast(id) }
+            end
+          end
+
+          def read_before_type_cast
+            variable_cache(:value_before_type_cast) do
+              Array.wrap(@value_cache)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        class ReferenceOne < Base
+          def write(value)
+            pollute do
+              previous = type_casted_value
+              result = write_value value
+              changed = (!value.nil? && type_casted_value.nil?) || type_casted_value != previous
+
+              association.reset if changed
+              result
+            end
+          end
+
+          def read
+            if association.target
+              association.identify
+            else
+              type_casted_value
+            end
+          end
+
+          def type_casted_value
+            variable_cache(:value) do
+              typecast(read_before_type_cast)
+            end
+          end
+
+          def read_before_type_cast
+            @value_cache
+          end
+
+          def type
+            @type ||= association.reflection.persistence_adapter.primary_key_type
+          end
+
+          def typecaster
+            @typecaster ||= Granite::Form.typecaster(type.ancestors.grep(Class))
+          end
+
+        private
+
+          def association
+            @association ||= owner.association(reflection.association)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Granite
+  module Form
+    module Model
+      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
+            end
+
+            def self.generate_methods(name, target)
+              target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                attribute('#{name}').read
+              end
+
+              def #{name}= value
+                attribute('#{name}').write(value)
+              end
+
+              def #{name}?
+                attribute('#{name}').query
+              end
+
+              def #{name}_before_type_cast
+                attribute('#{name}').read_before_type_cast
+              end
+
+              def #{name}_came_from_user?
+                attribute('#{name}').came_from_user?
+              end
+
+              def #{name}_default
+                attribute('#{name}').default
+              end
+
+              def #{name}_values
+                attribute('#{name}').enum.to_a
+              end
+              RUBY
+            end
+
+            def defaultizer
+              @defaultizer ||= options[:default]
+            end
+
+            def enumerizer
+              @enumerizer ||= options[:enum] || options[:in]
+            end
+
+            def normalizers
+              @normalizers ||= Array.wrap(options[:normalize] || options[:normalizer] || options[:normalizers])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        module Reflections
+          class Base
+            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)
+              end
+
+              def generate_methods(name, target) end
+
+              def attribute_class
+                @attribute_class ||= "Granite::Form::Model::Attributes::#{name.demodulize}".constantize
+              end
+            end
+
+            def initialize(name, options = {})
+              @name = name.to_s
+              @options = options
+            end
+
+            def build_attribute(owner, raw_value = Granite::Form::UNDEFINED)
+              attribute = self.class.attribute_class.new(name, owner)
+              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
+            end
+
+            def typecaster
+              @typecaster ||= Granite::Form.typecaster(type.ancestors.grep(Class))
+            end
+
+            def readonly
+              @readonly ||= options[:readonly]
+            end
+
+            def inspect_reflection
+              "#{name}: #{type}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        module Reflections
+          class Collection < Attribute
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        module Reflections
+          class Dictionary < Attribute
+            def keys
+              @keys ||= Array.wrap(options[:keys]).map(&:to_s)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        module Reflections
+          class Localized < Attribute
+            def self.build(target, generated_methods, name, *args, &block)
+              attribute = super(target, generated_methods, name, *args, &block)
+              generate_methods name, generated_methods
+              attribute
+            end
+
+            def self.generate_methods(name, target)
+              target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}_translations
+                attribute('#{name}').read
+              end
+
+              def #{name}_translations= value
+                attribute('#{name}').write(value)
+              end
+
+              def #{name}
+                attribute('#{name}').read_locale(self.class.locale)
+              end
+
+              def #{name}= value
+                attribute('#{name}').write_locale(value, self.class.locale)
+              end
+
+              def #{name}?
+                attribute('#{name}').locale_query(self.class.locale)
+              end
+
+              def #{name}_before_type_cast
+                attribute('#{name}').read_locale_before_type_cast(self.class.locale)
+              end
+              RUBY
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        module Reflections
+          class ReferenceMany < ReferenceOne
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Granite
+  module Form
+    module Model
+      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}
+                attribute('#{name}').read
+              end
+
+              def #{name}= value
+                attribute('#{name}').write(value)
+              end
+
+              def #{name}?
+                attribute('#{name}').query
+              end
+
+              def #{name}_before_type_cast
+                attribute('#{name}').read_before_type_cast
+              end
+              RUBY
+            end
+
+            def type
+              Object
+            end
+
+            def inspect_reflection
+              "#{name}: (reference)"
+            end
+
+            def association
+              @association ||= options[:association].to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        module Reflections
+          class Represents < Attribute
+            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
+
+              super(target, generated_methods, name, *args, options, &block)
+            end
+
+            def initialize(name, options)
+              super
+              raise ArgumentError, "Undefined reference for `#{name}`" if reference.blank?
+            end
+
+            def type
+              Object
+            end
+
+            def reference
+              @reference ||= options[:of].to_s
+            end
+
+            def column
+              @column ||= options[:column].presence.try(:to_s) || name
+            end
+
+            def reader
+              @reader ||= options[:reader].presence.try(:to_s) || column
+            end
+
+            def reader_before_type_cast
+              @reader_before_type_cast ||= "#{reader}_before_type_cast"
+            end
+
+            def writer
+              @writer ||= "#{options[:writer].presence || column}="
+            end
+
+            def inspect_reflection
+              "#{name}: (represents)"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        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
+            super
+            remove_variable(:cached_value, :cached_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
+          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)
+            end
+          end
+
+        private
+
+          def 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 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)
+            end
+          end
+
+          def cached_value_before_type_cast
+            variable_cache(:cached_value_before_type_cast) { read_value_before_type_cast }
+          end
+        end
+      end
+    end
+  end
+end