granite-form 0.1.0

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

@@ -0,0 +1,92 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        module Reflections
+          class Base
+            READ = ->(reflection, object) { object.read_attribute reflection.name }
+            WRITE = ->(reflection, object, value) { object.write_attribute reflection.name, value }
+
+            attr_reader :name, :options
+            # AR compatibility
+            attr_accessor :parent_reflection
+            delegate :association_class, to: 'self.class'
+
+            def self.build(target, generated_methods, name, options = {}, &_block)
+              generate_methods name, generated_methods
+              if options.delete(:validate) &&
+                  target.respond_to?(:validates_nested) &&
+                  !target.validates_nested?(name)
+                target.validates_nested name
+              end
+              new(name, options)
+            end
+
+            def self.generate_methods(name, target)
+              target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name} force_reload = false
+                association(:#{name}).reader(force_reload)
+              end
+
+              def #{name}= value
+                association(:#{name}).writer(value)
+              end
+              RUBY
+            end
+
+            def self.association_class
+              @association_class ||= "Granite::Form::Model::Associations::#{name.demodulize}".constantize
+            end
+
+            def initialize(name, options = {})
+              @name = name.to_sym
+              @options = options
+            end
+
+            def macro
+              self.class.name.demodulize.underscore.to_sym
+            end
+
+            def klass
+              @klass ||= (options[:class_name].presence || name.to_s.classify).to_s.constantize
+            end
+
+            # AR compatibility
+            def belongs_to?
+              false
+            end
+
+            def build_association(object)
+              self.class.association_class.new object, self
+            end
+
+            def read_source(object)
+              (options[:read] || READ).call(self, object)
+            end
+
+            def write_source(object, value)
+              (options[:write] || WRITE).call(self, object, value)
+            end
+
+            def default(object)
+              defaultizer = options[:default]
+              if defaultizer.is_a?(Proc)
+                if defaultizer.arity.nonzero?
+                  defaultizer.call(object)
+                else
+                  object.instance_exec(&defaultizer)
+                end
+              else
+                defaultizer
+              end
+            end
+
+            def collection?
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        module Reflections
+          class EmbedsAny < Base
+            class << self
+              def build(target, generated_methods, name, options = {}, &block)
+                if block
+                  options[:class] = proc do |reflection|
+                    superclass = reflection.options[:class_name].to_s.presence.try(:constantize)
+                    klass = build_class(superclass)
+                    target.const_set(name.to_s.classify, klass)
+                    klass.class_eval(&block)
+                    klass
+                  end
+                end
+                super
+              end
+
+              private def build_class(superclass)
+                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::Primary
+                  include Granite::Form.base_concern if Granite::Form.base_concern
+                end
+              end
+            end
+
+            def klass
+              @klass ||= if options[:class]
+                options[:class].call(self)
+              else
+                super
+              end
+            end
+
+            def inspect
+              "#{self.class.name.demodulize}(#{klass})"
+            end
+
+            def embedded?
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        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
+              options[:validate] = true unless options.key?(:validate)
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        module Reflections
+          class EmbedsOne < EmbedsAny
+            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
+              options[:validate] = true unless options.key?(:validate)
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        module Reflections
+          class ReferencesAny < Base
+            def self.build(_target, generated_methods, name, *args)
+              reflection = new(name, *args)
+              generate_methods name, generated_methods
+              reflection
+            end
+
+            def self.persistence_adapter(klass)
+              adapter = klass.granite_persistence_adapter if klass.respond_to?(:granite_persistence_adapter)
+              adapter or raise PersistenceAdapterMissing, klass
+            end
+
+            delegate :primary_key, to: :persistence_adapter
+
+            def initialize(name, *args)
+              @options = args.extract_options!
+              @scope_proc = args.first
+              @name = name.to_sym
+            end
+
+            def klass
+              @klass ||= if options[:data_source].present?
+                options[:data_source].to_s.constantize
+              else
+                super
+              end
+            end
+
+            alias_method :data_source, :klass
+
+            def persistence_adapter
+              @persistence_adapter ||= self.class.persistence_adapter(klass)
+                .new(data_source, options[:primary_key], @scope_proc)
+            end
+
+            def read_source(object)
+              object.read_attribute(reference_key)
+            end
+
+            def write_source(object, value)
+              object.write_attribute(reference_key, value)
+            end
+
+            def embedded?
+              false
+            end
+
+            def inspect
+              "#{self.class.name.demodulize}(#{persistence_adapter.data_type})"
+            end
+
+            def autosave?
+              !!options[:autosave]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'granite/form/model/attributes/reflections/reference_many'
+require 'granite/form/model/attributes/reference_many'
+
+module Granite
+  module Form
+    module Model
+      module Associations
+        module Reflections
+          class ReferencesMany < ReferencesAny
+            def self.build(target, generated_methods, name, *args, &block)
+              reflection = super
+
+              target.add_attribute(
+                Granite::Form::Model::Attributes::Reflections::ReferenceMany,
+                reflection.reference_key, association: name
+              )
+
+              reflection
+            end
+
+            def reference_key
+              @reference_key ||= options[:reference_key].presence.try(:to_sym) ||
+                :"#{name.to_s.singularize}_#{primary_key.to_s.pluralize}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'granite/form/model/attributes/reflections/reference_one'
+require 'granite/form/model/attributes/reference_one'
+
+module Granite
+  module Form
+    module Model
+      module Associations
+        module Reflections
+          class ReferencesOne < ReferencesAny
+            include Singular
+
+            def self.build(target, generated_methods, name, *args, &block)
+              reflection = super
+
+              target.add_attribute(
+                Granite::Form::Model::Attributes::Reflections::ReferenceOne,
+                reflection.reference_key, association: name
+              )
+
+              reflection
+            end
+
+            def reference_key
+              @reference_key ||= options[:reference_key].presence.try(:to_sym) ||
+                :"#{name}_#{primary_key}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,41 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        module Validations
+          def valid_ancestry?
+            errors.clear
+            validate_nested!
+            run_validations!
+          end
+
+          alias_method :validate_ancestry, :valid_ancestry?
+
+          def invalid_ancestry?
+            !valid_ancestry?
+          end
+
+          def validate_ancestry!
+            valid_ancestry? || raise_validation_error
+          end
+
+        private
+
+          def validate_nested!
+            association_names.each do |name|
+              association = association(name)
+              invalid_block = if association.reflection.klass.method_defined?(:invalid_ansestry?)
+                ->(object) { object.invalid_ansestry? }
+              else
+                ->(object) { object.invalid? }
+              end
+
+              Granite::Form::Model::Validations::NestedValidator
+                .validate_nested(self, name, association.target, &invalid_block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+require 'granite/form/model/associations/collection/proxy'
+require 'granite/form/model/associations/collection/embedded'
+
+require 'granite/form/model/associations/reflections/base'
+require 'granite/form/model/associations/reflections/singular'
+require 'granite/form/model/associations/reflections/embeds_any'
+require 'granite/form/model/associations/reflections/embeds_one'
+require 'granite/form/model/associations/reflections/embeds_many'
+require 'granite/form/model/associations/reflections/references_any'
+require 'granite/form/model/associations/reflections/references_one'
+require 'granite/form/model/associations/reflections/references_many'
+
+require 'granite/form/model/associations/base'
+require 'granite/form/model/associations/embeds_any'
+require 'granite/form/model/associations/embeds_one'
+require 'granite/form/model/associations/embeds_many'
+require 'granite/form/model/associations/references_any'
+require 'granite/form/model/associations/references_one'
+require 'granite/form/model/associations/references_many'
+
+require 'granite/form/model/associations/nested_attributes'
+require 'granite/form/model/associations/validations'
+
+module Granite
+  module Form
+    module Model
+      module Associations
+        extend ActiveSupport::Concern
+
+        included do
+          include NestedAttributes
+
+          class_attribute :_associations, :_association_aliases, instance_reader: false, instance_writer: false
+          self._associations = {}
+          self._association_aliases = {}
+
+          delegate :association_names, to: 'self.class'
+
+          {
+            embeds_many: Reflections::EmbedsMany,
+            embeds_one: Reflections::EmbedsOne,
+            references_one: Reflections::ReferencesOne,
+            references_many: Reflections::ReferencesMany
+          }.each do |(name, reflection_class)|
+            define_singleton_method name do |*args, &block|
+              reflection = reflection_class.build self, generated_associations_methods, *args, &block
+              self._associations = _associations.merge(reflection.name => reflection)
+              reflection
+            end
+          end
+        end
+
+        module ClassMethods
+          def reflections
+            _associations
+          end
+
+          def alias_association(alias_name, association_name)
+            reflection = reflect_on_association(association_name)
+            raise ArgumentError, "Can't alias undefined association `#{attribute_name}` on #{self}" unless reflection
+            reflection.class.generate_methods alias_name, generated_associations_methods
+            self._association_aliases = _association_aliases.merge(alias_name.to_sym => reflection.name)
+            reflection
+          end
+
+          def reflect_on_association(name)
+            name = name.to_sym
+            _associations[_association_aliases[name] || name]
+          end
+
+          def association_names
+            _associations.keys
+          end
+
+        private
+
+          def attributes_for_inspect
+            (_associations.map do |name, reflection|
+              "#{name}: #{reflection.inspect}"
+            end + [super]).join(', ')
+          end
+
+          def generated_associations_methods
+            @generated_associations_methods ||= const_set(:GeneratedAssociationsMethods, Module.new)
+              .tap { |proxy| include proxy }
+          end
+        end
+
+        def ==(other)
+          super && association_names.all? do |association|
+            public_send(association) == other.public_send(association)
+          end
+        end
+
+        alias_method :eql?, :==
+
+        def association(name)
+          reflection = self.class.reflect_on_association(name)
+          return unless reflection
+          (@_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
+          (association_names.map do |name|
+            association = association(name)
+            "#{name}: #{association.inspect}"
+          end + [super]).join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module Granite
+  module Form
+    module Model
+      module Attributes
+        class Attribute < Base
+          delegate :defaultizer, :enumerizer, :normalizers, to: :reflection
+
+          def write(value)
+            return if readonly?
+            pollute do
+              write_value value
+            end
+          end
+
+          def read
+            variable_cache(:value) do
+              normalize(enumerize(typecast(read_before_type_cast)))
+            end
+          end
+
+          def read_before_type_cast
+            variable_cache(:value_before_type_cast) do
+              defaultize(@value_cache)
+            end
+          end
+
+          def default
+            defaultizer.is_a?(Proc) ? evaluate(&defaultizer) : 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
+            else
+              normalizers.inject(value) do |val, normalizer|
+                case normalizer
+                when Proc
+                  evaluate(val, &normalizer)
+                when Hash
+                  normalizer.inject(val) do |v, (name, options)|
+                    Granite::Form.normalizer(name).call(v, options, self)
+                  end
+                else
+                  Granite::Form.normalizer(normalizer).call(val, {}, self)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end