granite-form 0.1.0

data/lib/granite/form/config.rb

@@ -0,0 +1,42 @@
+module Granite
+  module Form
+    class Config
+      include Singleton
+
+      attr_accessor :include_root_in_json, :i18n_scope, :logger, :primary_attribute, :base_class, :base_concern,
+        :_normalizers, :_typecasters
+
+      def self.delegated
+        public_instance_methods - superclass.public_instance_methods - Singleton.public_instance_methods
+      end
+
+      def initialize
+        @include_root_in_json = false
+        @i18n_scope = :granite
+        @logger = Logger.new(STDERR)
+        @primary_attribute = :id
+        @_normalizers = {}
+        @_typecasters = {}
+      end
+
+      def normalizer(name, &block)
+        if block
+          _normalizers[name.to_sym] = block
+        else
+          _normalizers[name.to_sym] or raise NormalizerMissing, name
+        end
+      end
+
+      def typecaster(*classes, &block)
+        classes = classes.flatten
+        if block
+          _typecasters[classes.first.to_s.camelize] = block
+        else
+          _typecasters[classes.detect do |klass|
+            _typecasters[klass.to_s.camelize]
+          end.to_s.camelize] or raise TypecasterMissing, classes
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/errors.rb

@@ -0,0 +1,111 @@
+module Granite
+  module Form
+    class Error < StandardError
+    end
+
+    class NotFound < Error
+    end
+
+    # Backported from active_model 5
+    class ValidationError < Error
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+        errors = @model.errors.full_messages.join(', ')
+        super(I18n.t(:"#{@model.class.i18n_scope}.errors.messages.model_invalid", errors: errors, default: :'errors.messages.model_invalid'))
+      end
+    end
+
+    class UnsavableObject < Error
+    end
+
+    class UndestroyableObject < Error
+    end
+
+    class ObjectNotSaved < Error
+    end
+
+    class ObjectNotDestroyed < Error
+    end
+
+    class AssociationChangesNotApplied < Error
+    end
+
+    class AssociationTypeMismatch < Error
+      def initialize(expected, got)
+        super "Expected `#{expected}` (##{expected.object_id}), but got `#{got}` (##{got.object_id})"
+      end
+    end
+
+    class ObjectNotFound < Error
+      def initialize(object, association_name, record_id)
+        message = "Couldn't find #{object.class.reflect_on_association(association_name).klass.name}" \
+        "with #{object.respond_to?(:_primary_name) ? object._primary_name : 'id'} = #{record_id} for #{object.inspect}"
+        super message
+      end
+    end
+
+    class TooManyObjects < Error
+      def initialize(limit, actual_size)
+        super "Maximum #{limit} objects are allowed. Got #{actual_size} objects instead."
+      end
+    end
+
+    class UndefinedPrimaryAttribute < Error
+      def initialize(klass, association_name)
+        super <<-MESSAGE
+Undefined primary attribute for `#{association_name}` in #{klass}.
+It is required for embeds_many nested attributes proper operation.
+You can define this association as:
+
+  embeds_many :#{association_name} do
+    primary :attribute_name
+  end
+        MESSAGE
+      end
+    end
+
+    class NormalizerMissing < NoMethodError
+      def initialize(name)
+        super <<-MESSAGE
+Could not find normalizer `:#{name}`
+You can define it with:
+
+  Granite::Form.normalizer(:#{name}) do |value, options|
+    # do some staff with value and options
+  end
+        MESSAGE
+      end
+    end
+
+    class TypecasterMissing < NoMethodError
+      def initialize(*classes)
+        classes = classes.flatten
+        super <<-MESSAGE
+Could not find typecaster for #{classes}
+You can define it with:
+
+  Granite::Form.typecaster('#{classes.first}') do |value|
+    # do some staff with value and options
+  end
+        MESSAGE
+      end
+    end
+
+    class PersistenceAdapterMissing < NoMethodError
+      def initialize(data_source)
+        super <<-MESSAGE
+Could not find persistence adapter for #{data_source}
+You can define it with:
+
+  class #{data_source}
+    def self.granite_persistence_adapter
+      #{data_source}GraniteFormPersistenceAdapter
+    end
+  end
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/granite/form/extensions.rb

@@ -0,0 +1,36 @@
+class Boolean; end unless defined?(Boolean)
+
+begin
+  require 'uuidtools'
+rescue LoadError
+  nil
+else
+  module Granite
+    module Form
+      class UUID < UUIDTools::UUID
+        def as_json(*_)
+          to_s
+        end
+
+        def to_param
+          to_s
+        end
+
+        def self.parse_string(value)
+          return nil if value.length.zero?
+          if value.length == 36
+            parse value
+          elsif value.length == 32
+            parse_hexdigest value
+          else
+            parse_raw value
+          end
+        end
+
+        def inspect
+          "#<Granite::Form::UUID:#{self}>"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        class Base
+          attr_accessor :owner, :reflection
+          delegate :macro, :collection?, to: :reflection
+
+          def initialize(owner, reflection)
+            @owner = owner
+            @reflection = reflection
+            @evar_loaded = owner.persisted?
+            reset
+          end
+
+          def reset
+            @loaded = false
+            @target = nil
+          end
+
+          def evar_loaded?
+            !!@evar_loaded
+          end
+
+          def loaded?
+            !!@loaded
+          end
+
+          def loaded!
+            @evar_loaded = true
+            @loaded = true
+          end
+
+          def target
+            return @target if loaded?
+            self.target = load_target
+          end
+
+          def reload
+            reset
+            target
+          end
+
+          def apply_changes!
+            apply_changes or raise Granite::Form::AssociationChangesNotApplied
+          end
+
+          def callback(name, object)
+            evaluator = reflection.options[name]
+            return true unless evaluator
+
+            if evaluator.is_a?(Proc)
+              if evaluator.arity == 1
+                owner.instance_exec(object, &evaluator)
+              else
+                evaluator.call(owner, object)
+              end
+            else
+              owner.send(evaluator, object)
+            end
+          end
+
+          def transaction
+            data = read_source.deep_dup
+            yield
+          rescue StandardError => e
+            write_source data
+            reload
+            raise e
+          end
+
+          def inspect
+            "#<#{reflection.macro.to_s.camelize} #{target.inspect.truncate(50, omission: collection? ? '...]' : '...')}>"
+          end
+
+        private
+
+          def read_source
+            reflection.read_source owner
+          end
+
+          def write_source(value)
+            reflection.write_source owner, value
+          end
+
+          def target_for_inspect
+            if value.length > 50
+              "#{value[0..50]}...".inspect
+            else
+              value.inspect
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        module Collection
+          class Embedded < Proxy
+            delegate :build, :create, :create!, to: :@association
+            alias_method :new, :build
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        module Collection
+          class Proxy
+            include Enumerable
+
+            delegate :target, :save, :save!, :loaded?, :reload, :clear, :concat, to: :@association
+            delegate :each, :size, :length, :first, :last, :empty?, :many?, :==, :dup, to: :target
+            alias_method :<<, :concat
+            alias_method :push, :concat
+
+            def initialize(association)
+              @association = association
+            end
+
+            def to_ary
+              dup
+            end
+
+            alias_method :to_a, :to_ary
+
+            def inspect
+              entries = target.take(10).map!(&:inspect)
+              entries[10] = '...' if target.size > 10
+
+              "#<#{self.class.name.demodulize} [#{entries.join(', ')}]>"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        class EmbedsAny < Base
+        private
+
+          def build_object(attributes)
+            reflection.klass.new(attributes)
+          end
+
+          def embed_object(object)
+            object.instance_variable_set(:@embedder, owner)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        class EmbedsMany < EmbedsAny
+          def build(attributes = {})
+            push_object(build_object(attributes))
+          end
+
+          def create(attributes = {})
+            build(attributes).tap(&:save)
+          end
+
+          def create!(attributes = {})
+            build(attributes).tap(&:save!)
+          end
+
+          def destroyed
+            @destroyed ||= []
+          end
+
+          def apply_changes
+            result = target.map do |object|
+              object.destroyed? || object.marked_for_destruction? ? object.destroy : object.save
+            end.all?
+            @destroyed = target.select(&:destroyed?)
+            target.delete_if(&:destroyed?)
+            result
+          end
+
+          def target=(objects)
+            objects.each { |object| setup_performers! object }
+            loaded!
+            @target = objects
+          end
+
+          def load_target
+            source = read_source
+            source.present? ? reflection.klass.instantiate_collection(source) : default
+          end
+
+          def default
+            unless evar_loaded?
+              default = Array.wrap(reflection.default(owner))
+              if default.present?
+                collection = if default.all? { |object| object.is_a?(reflection.klass) }
+                  default
+                else
+                  default.map do |attributes|
+                    reflection.klass.with_sanitize(false) do
+                      build_object(attributes)
+                    end
+                  end
+                end
+                collection.map { |object| object.send(:clear_changes_information) } if reflection.klass.dirty?
+                collection
+              end
+            end || []
+          end
+
+          def reset
+            super
+            @target = []
+          end
+
+          def clear
+            begin
+              transaction { target.all?(&:destroy!) }
+            rescue Granite::Form::ObjectNotDestroyed
+              nil
+            end
+            reload.empty?
+          end
+
+          def reader(force_reload = false)
+            reload if force_reload
+            @proxy ||= Collection::Embedded.new self
+          end
+
+          def replace(objects)
+            transaction do
+              clear
+              append(objects) or raise Granite::Form::AssociationChangesNotApplied
+            end
+          end
+
+          alias_method :writer, :replace
+
+          def concat(*objects)
+            append objects.flatten
+          end
+
+        private
+
+          def read_source
+            super || []
+          end
+
+          def append(objects)
+            objects.each do |object|
+              raise AssociationTypeMismatch.new(reflection.klass, object.class) unless object && object.is_a?(reflection.klass)
+              push_object object
+            end
+            result = owner.persisted? ? apply_changes : true
+            result && target
+          end
+
+          def push_object(object)
+            setup_performers! object
+            target[target.size] = object
+            object
+          end
+
+          def setup_performers!(object)
+            embed_object(object)
+            callback(:before_add, object)
+
+            association = self
+
+            object.define_create do
+              source = association.send(:read_source)
+              index = association.target
+                .select { |one| one.persisted? || one.equal?(self) }
+                .index { |one| one.equal?(self) }
+
+              source.insert(index, attributes)
+              association.send(:write_source, source)
+            end
+
+            object.define_update do
+              source = association.send(:read_source)
+              index = association.target.select(&:persisted?).index { |one| one.equal?(self) }
+
+              source[index] = attributes
+              association.send(:write_source, source)
+            end
+
+            object.define_destroy do
+              source = association.send(:read_source)
+              index = association.target.select(&:persisted?).index { |one| one.equal?(self) }
+
+              source.delete_at(index) if index
+              association.send(:write_source, source)
+            end
+
+            callback(:after_add, object)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+module Granite
+  module Form
+    module Model
+      module Associations
+        class EmbedsOne < EmbedsAny
+          attr_reader :destroyed
+
+          def build(attributes = {})
+            self.target = build_object(attributes)
+          end
+
+          def create(attributes = {})
+            build(attributes).tap(&:save)
+          end
+
+          def create!(attributes = {})
+            build(attributes).tap(&:save!)
+          end
+
+          def apply_changes
+            if target
+              if target.destroyed? || target.marked_for_destruction?
+                @destroyed = target
+                clear
+              else
+                target.save
+              end
+            else
+              true
+            end
+          end
+
+          def target=(object)
+            if object
+              callback(:before_add, object)
+              setup_performers! object
+            end
+            loaded!
+            @target = object
+            callback(:after_add, object) if object
+          end
+
+          def load_target
+            source = read_source
+            source ? reflection.klass.instantiate(source) : default
+          end
+
+          def default
+            return if evar_loaded?
+
+            default = reflection.default(owner)
+
+            return unless default
+
+            object = if default.is_a?(reflection.klass)
+              default
+            else
+              reflection.klass.with_sanitize(false) do
+                build_object(default)
+              end
+            end
+            object.send(:clear_changes_information) if reflection.klass.dirty?
+            object
+          end
+
+          def clear
+            target.try(:destroy)
+            reload.nil?
+          end
+
+          def reader(force_reload = false)
+            reload if force_reload
+            target
+          end
+
+          def replace(object)
+            if object
+              raise AssociationTypeMismatch.new(reflection.klass, object.class) unless object.is_a?(reflection.klass)
+              transaction do
+                clear
+                self.target = object
+                apply_changes! if owner.persisted?
+              end
+            else
+              clear
+            end
+
+            target
+          end
+
+          alias_method :writer, :replace
+
+        private
+
+          def setup_performers!(object)
+            embed_object(object)
+            association = self
+
+            object.define_save do
+              association.send(:write_source, attributes)
+            end
+
+            object.define_destroy do
+              association.send(:write_source, nil)
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end