granite-form 0.1.0

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

@@ -0,0 +1,204 @@
+require 'granite/form/model/attributes/reflections/base'
+require 'granite/form/model/attributes/reflections/attribute'
+require 'granite/form/model/attributes/reflections/collection'
+require 'granite/form/model/attributes/reflections/dictionary'
+
+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
+    module Model
+      module Attributes
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :_attributes, :_attribute_aliases, :_sanitize, instance_reader: false, instance_writer: false
+          self._attributes = {}
+          self._attribute_aliases = {}
+          self._sanitize = true
+
+          delegate :attribute_names, :has_attribute?, to: 'self.class'
+
+          %w[attribute collection dictionary].each do |kind|
+            define_singleton_method kind do |*args, &block|
+              add_attribute("Granite::Form::Model::Attributes::Reflections::#{kind.camelize}".constantize, *args, &block)
+            end
+          end
+        end
+
+        module ClassMethods
+          def add_attribute(reflection_class, *args, &block)
+            reflection = reflection_class.build(self, generated_attributes_methods, *args, &block)
+            self._attributes = _attributes.merge(reflection.name => reflection)
+            should_define_dirty = (dirty? && reflection_class != Granite::Form::Model::Attributes::Reflections::Base)
+            define_dirty(reflection.name, generated_attributes_methods) if should_define_dirty
+            reflection
+          end
+
+          def alias_attribute(alias_name, attribute_name)
+            reflection = reflect_on_attribute(attribute_name)
+            raise ArgumentError, "Unable to alias undefined attribute `#{attribute_name}` on #{self}" unless reflection
+            raise ArgumentError, "Unable to alias base attribute `#{attribute_name}`" if reflection.class == Granite::Form::Model::Attributes::Reflections::Base
+            reflection.class.generate_methods alias_name, generated_attributes_methods
+            self._attribute_aliases = _attribute_aliases.merge(alias_name.to_s => reflection.name)
+            define_dirty alias_name, generated_attributes_methods if dirty?
+            reflection
+          end
+
+          def reflect_on_attribute(name)
+            name = name.to_s
+            _attributes[_attribute_aliases[name] || name]
+          end
+
+          def has_attribute?(name) # rubocop:disable Naming/PredicateName
+            name = name.to_s
+            _attributes.key?(_attribute_aliases[name] || name)
+          end
+
+          def attribute_names(include_associations = true)
+            if include_associations
+              _attributes.keys
+            else
+              _attributes.map do |name, attribute|
+                name unless attribute.class == Granite::Form::Model::Attributes::Reflections::Base
+              end.compact
+            end
+          end
+
+          def inspect
+            "#{original_inspect}(#{attributes_for_inspect.presence || 'no attributes'})"
+          end
+
+          def dirty?
+            false
+          end
+
+          def with_sanitize(value)
+            previous_sanitize = _sanitize
+            self._sanitize = value
+            yield
+          ensure
+            self._sanitize = previous_sanitize
+          end
+
+        private
+
+          def original_inspect
+            Object.method(:inspect).unbind.bind(self).call
+          end
+
+          def attributes_for_inspect
+            attribute_names(false).map do |name|
+              prefix = respond_to?(:_primary_name) && _primary_name == name ? '*' : ''
+              "#{prefix}#{_attributes[name].inspect_reflection}"
+            end.join(', ')
+          end
+
+          def generated_attributes_methods
+            @generated_attributes_methods ||=
+              const_set(:GeneratedAttributesMethods, Module.new)
+                .tap { |proxy| include proxy }
+          end
+
+          def inverted_attribute_aliases
+            @inverted_attribute_aliases ||=
+              _attribute_aliases.each.with_object({}) do |(alias_name, attribute_name), result|
+                (result[attribute_name] ||= []).push(alias_name)
+              end
+          end
+        end
+
+        def initialize(attrs = {})
+          assign_attributes attrs
+        end
+
+        def ==(other)
+          super || other.instance_of?(self.class) && other.attributes(false) == attributes(false)
+        end
+
+        alias_method :eql?, :==
+
+        def attribute(name)
+          reflection = self.class.reflect_on_attribute(name)
+          return unless reflection
+          initial_value = @initial_attributes.to_h.fetch(reflection.name, Granite::Form::UNDEFINED)
+          @_attributes ||= {}
+          @_attributes[reflection.name] ||= reflection.build_attribute(self, initial_value)
+        end
+
+        def write_attribute(name, value)
+          attribute(name).write(value)
+        end
+
+        alias_method :[]=, :write_attribute
+
+        def read_attribute(name)
+          attribute(name).read
+        end
+
+        alias_method :[], :read_attribute
+
+        def read_attribute_before_type_cast(name)
+          attribute(name).read_before_type_cast
+        end
+
+        def attribute_came_from_user?(name)
+          attribute(name).came_from_user?
+        end
+
+        def attribute_present?(name)
+          attribute(name).value_present?
+        end
+
+        def attributes(include_associations = true)
+          Hash[attribute_names(include_associations).map { |name| [name, read_attribute(name)] }]
+        end
+
+        def update(attrs)
+          assign_attributes(attrs)
+        end
+
+        alias_method :update_attributes, :update
+
+        def assign_attributes(attrs)
+          attrs.each do |name, value|
+            name = name.to_s
+            sanitize_value = self.class._sanitize && name == self.class.primary_name
+
+            if respond_to?("#{name}=") && !sanitize_value
+              public_send("#{name}=", value)
+            else
+              logger.info("Ignoring #{sanitize_value ? 'primary' : 'undefined'} `#{name}` attribute value for #{self} during mass-assignment")
+            end
+          end
+        end
+
+        alias_method :attributes=, :assign_attributes
+
+        def inspect
+          "#<#{self.class.send(:original_inspect)} #{attributes_for_inspect.presence || '(no attributes)'}>"
+        end
+
+        def initialize_copy(_)
+          @initial_attributes = Hash[attribute_names.map do |name|
+            [name, read_attribute_before_type_cast(name)]
+          end]
+          @_attributes = nil
+          super
+        end
+
+      private
+
+        def attributes_for_inspect
+          attribute_names(false).map do |name|
+            prefix = self.class.primary_name == name ? '*' : ''
+            "#{prefix}#{attribute(name).inspect_attribute}"
+          end.join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Granite
+  module Form
+    module Model
+      # == Callbacks for Granite::Form::Model lifecycle
+      #
+      # Provides ActiveModel callbacks support for lifecycle
+      # actions.
+      #
+      #   class Book
+      #     include Granite::Form::Model
+      #
+      #     attribute :id, Integer
+      #     attribute :title, String
+      #
+      #     define_save do
+      #       REDIS.set(id, attributes.to_json)
+      #     end
+      #
+      #     define_destroy do
+      #       REDIS.del(instance.id)
+      #     end
+      #
+      #     after_initialize :setup_id
+      #     before_save :do_something
+      #     around_update do |&block|
+      #       ...
+      #       block.call
+      #       ...
+      #     end
+      #     after_destroy { ... }
+      #   end
+      #
+      module Callbacks
+        extend ActiveSupport::Concern
+
+        included do
+          extend ActiveModel::Callbacks
+
+          include ActiveModel::Validations::Callbacks
+          include Lifecycle
+          prepend PrependMethods
+
+          define_model_callbacks :initialize, only: :after
+          define_model_callbacks :save, :create, :update, :destroy
+        end
+
+        module PrependMethods
+          def initialize(*_)
+            super
+            run_callbacks :initialize
+          end
+
+          def save_object(&block)
+            run_callbacks(:save) { super(&block) }
+          end
+
+          def create_object(&block)
+            run_callbacks(:create) { super(&block) }
+          end
+
+          def update_object(&block)
+            run_callbacks(:update) { super(&block) }
+          end
+
+          def destroy_object(&block)
+            run_callbacks(:destroy) { super(&block) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Granite
+  module Form
+    module Model
+      module Conventions
+        extend ActiveSupport::Concern
+
+        included do
+          attr_reader :embedder
+
+          delegate :logger, to: Granite::Form
+          self.include_root_in_json = Granite::Form.include_root_in_json
+        end
+
+        def persisted?
+          false
+        end
+
+        def new_record?
+          !persisted?
+        end
+
+        alias_method :new_object?, :new_record?
+
+        module ClassMethods
+          def i18n_scope
+            Granite::Form.i18n_scope
+          end
+
+          def to_ary
+            nil
+          end
+
+          def primary_name
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module Granite
+  module Form
+    module Model
+      module Dirty
+        extend ActiveSupport::Concern
+
+        ::Module.class_eval do
+          alias_method :unconcerned_append_features, :append_features
+        end
+
+        DIRTY_CLONE = ActiveModel::Dirty.clone
+        DIRTY_CLONE.class_eval do
+          def self.append_features(base)
+            unconcerned_append_features(base)
+          end
+
+          def self.included(_base); end
+        end
+
+        include DIRTY_CLONE
+
+        included do
+          attribute_names(false).each do |name|
+            define_dirty name, generated_attributes_methods
+          end
+          _attribute_aliases.each_key do |name|
+            define_dirty name, generated_attributes_methods
+          end
+        end
+
+        if !method_defined?(:set_attribute_was) && !private_method_defined?(:set_attribute_was)
+          private def set_attribute_was(attr, old_value)
+            changed_attributes[attr] = old_value
+          end
+        end
+
+        unless method_defined?(:clear_changes_information)
+          if method_defined?(:reset_changes)
+            def clear_changes_information
+              reset_changes
+            end
+          else
+            def clear_changes_information
+              @previously_changed = nil
+              @changed_attributes = nil
+            end
+          end
+        end
+
+        unless method_defined?(:_read_attribute)
+          def _read_attribute(attr)
+            __send__(attr)
+          end
+        end
+
+        module ClassMethods
+          def define_dirty(method, target = self)
+            reflection = reflect_on_attribute(method)
+            name = reflection ? reflection.name : method
+
+            %w[changed? change will_change! was
+               previously_changed? previous_change].each do |suffix|
+              target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method}_#{suffix}
+                attribute_#{suffix} '#{name}'
+              end
+              RUBY
+            end
+
+            target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def restore_#{method}!
+              restore_attribute! '#{name}'
+            end
+            RUBY
+          end
+
+          def dirty?
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,309 @@
+module Granite
+  module Form
+    module Model
+      # == Lifecycle methods for Granite::Form::Model
+      #
+      # Provides methods +save+ and +destroy+ and its bang variants.
+      # Also, patches +create+ and +update_attributes+ methods by adding
+      # save at the end.
+      #
+      # You can define save or destroy performers with <tt>define_<action></tt>
+      # methods. Create and update performers might be defined instead of
+      # save performer:
+      #
+      #   class Book
+      #     include Granite::Form::Model
+      #     include Granite::Form::Model::Lifecycle
+      #
+      #     attribute :id, Integer
+      #     attribute :title, String
+      #
+      #     define_save do # executes in the instance scope
+      #       REDIS.set(id, attributes.to_json)
+      #     end
+      #
+      #     define_destroy do
+      #       REDIS.del(id)
+      #     end
+      #   end
+      #
+      #   class Author
+      #     include Granite::Form::Model
+      #     include Granite::Form::Model::Lifecycle
+      #
+      #     attribute :id, Integer
+      #     attribute :name, String
+      #
+      #     define_create do # will be called on create only
+      #       REDIS.sadd('author_ids', id)
+      #       REDIS.set(id, attributes.to_json)
+      #     end
+      #
+      #     define_update do # will be called on update only
+      #       REDIS.set(id, attributes.to_json)
+      #     end
+      #   end
+      #
+      # In case of undefined performer Granite::Form::UnsavableObject
+      # or Granite::Form::UndestroyableObject will be raised respectively.
+      #
+      # If performers was not defined in model, they cat be passed as
+      # blocks to `save`, `update` and `destroy` methods:
+      #
+      #   authos.save { REDIS.set(id, attributes.to_json) }
+      #   authos.update { REDIS.set(id, attributes.to_json) }
+      #   authos.destroy { REDIS.del(id) }
+      #
+      # Save and destroy processes acts almost the save way as
+      # ActiveRecord's (with +persisted?+ and +destroyed?+ methods
+      # affecting).
+      #
+      module Lifecycle
+        extend ActiveSupport::Concern
+
+        included do
+          include Persistence
+
+          class_attribute(*%i[save create update destroy].map { |action| "_#{action}_performer" })
+          private(*%i[save create update destroy].map { |action| "_#{action}_performer=" })
+        end
+
+        module ClassMethods
+          # <tt>define_<action></tt> methods define performers for lifecycle
+          # actions. Every action block must return boolean result, which
+          # would mean the action success. If action performed unsuccessfully
+          # Granite::Form::ObjectNotSaved or Granite::Form::ObjectNotDestroyed will
+          # be raised respectively in case of bang methods using.
+          #
+          #   class Author
+          #     define_create { true }
+          #   end
+          #
+          #   Author.new.save # => true
+          #   Author.new.save! # => true
+          #
+          #   class Author
+          #     define_create { false }
+          #   end
+          #
+          #   Author.new.save # => false
+          #   Author.new.save! # => Granite::Form::ObjectNotSaved
+          #
+          # Also performers blocks are executed in the instance context, but
+          # instance also passed as argument
+          #
+          #   define_update do |instance|
+          #      instance.attributes.to_json
+          #   end
+          #
+          # +define_create+ and +define_update+ performers has higher priority
+          # than +define_save+.
+          #
+          #   class Author
+          #     define_update { ... }
+          #     define_save { ... }
+          #   end
+          #
+          #   author = Author.create # using define_save performer
+          #   author.update_attributes(...) # using define_update performer
+          #
+          %i[save create update destroy].each do |action|
+            define_method "define_#{action}" do |&block|
+              send("_#{action}_performer=", block)
+            end
+          end
+
+          # Initializes new instance with attributes passed and calls +save+
+          # on it. Returns instance in any case.
+          #
+          def create(*args)
+            new(*args).tap(&:save)
+          end
+
+          # Initializes new instance with attributes passed and calls +save!+
+          # on it. Returns instance in case of success and raises Granite::Form::ValidationError
+          # or Granite::Form::ObjectNotSaved in case of validation or saving fail respectively.
+          #
+          def create!(*args)
+            new(*args).tap(&:save!)
+          end
+        end
+
+        # <tt>define_<action></tt> on instance level works the same
+        # way as class <tt>define_<action></tt> methods, but defines
+        # performers for instance only
+        #
+        #   user.define_save do
+        #     REDIS.set(id, attributes.to_json)
+        #   end
+        #   user.save! # => will use instance-level performer
+        #
+        %i[save create update destroy].each do |action|
+          define_method "define_#{action}" do |&block|
+            send("_#{action}_performer=", block)
+          end
+        end
+
+        # Assigns passed attributes and calls +save+
+        # Returns true or false in case of successful or unsuccessful
+        # saving respectively.
+        #
+        #   author.update(name: 'Donald')
+        #
+        # If update performer is not defined with `define_update`
+        # or `define_save`, it raises Granite::Form::UnsavableObject.
+        # Also save performer block might be passed instead of in-class
+        # performer definition:
+        #
+        #   author.update(name: 'Donald') { REDIS.set(id, attributes.to_json) }
+        #
+        def update(attributes, &block)
+          assign_attributes(attributes) && save(&block)
+        end
+
+        alias_method :update_attributes, :update
+
+        # Assigns passed attributes and calls +save!+
+        # Returns true in case of success and raises Granite::Form::ValidationError
+        # or Granite::Form::ObjectNotSaved in case of validation or
+        # saving fail respectively.
+        #
+        #   author.update!(name: 'Donald')
+        #
+        # If update performer is not defined with `define_update`
+        # or `define_save`, it raises Granite::Form::UnsavableObject.
+        # Also save performer block might be passed instead of in-class
+        # performer definition:
+        #
+        #   author.update!(name: 'Donald') { REDIS.set(id, attributes.to_json) }
+        #
+        def update!(attributes, &block)
+          assign_attributes(attributes) && save!(&block)
+        end
+
+        alias_method :update_attributes!, :update!
+
+        # # Saves object by calling save performer defined with +define_save+,
+        # +define_create+ or +define_update+ methods.
+        # Returns true or false in case of successful
+        # or unsuccessful saving respectively. Changes +persisted?+ to true
+        #
+        #   author.save
+        #
+        # If save performer is not defined with `define_update` or
+        # `define_create` or `define_save`, it raises Granite::Form::UnsavableObject.
+        # Also save performer block might be passed instead of in-class
+        # performer definition:
+        #
+        #   author.save { REDIS.set(id, attributes.to_json) }
+        #
+        def save(_options = {}, &block)
+          raise Granite::Form::UnsavableObject unless block || savable?
+          valid? && save_object(&block)
+        end
+
+        # Saves object by calling save performer defined with +define_save+,
+        # +define_create+ or +define_update+ methods.
+        # Returns true in case of success and raises Granite::Form::ValidationError
+        # or Granite::Form::ObjectNotSaved in case of validation or
+        # saving fail respectively. Changes +persisted?+ to true
+        #
+        #   author.save!
+        #
+        # If save performer is not defined with `define_update` or
+        # `define_create` or `define_save`, it raises Granite::Form::UnsavableObject.
+        # Also save performer block might be passed instead of in-class
+        # performer definition:
+        #
+        #   author.save! { REDIS.set(id, attributes.to_json) }
+        #
+        def save!(_options = {}, &block)
+          raise Granite::Form::UnsavableObject unless block || savable?
+          validate!
+          save_object(&block) or raise Granite::Form::ObjectNotSaved
+        end
+
+        # Destroys object by calling the destroy performer.
+        # Returns instance in any case. Changes +persisted?+
+        # to false and +destroyed?+ to true in case of success.
+        #
+        #   author.destroy
+        #
+        # If destroy performer is not defined with `define_destroy`,
+        # it raises Granite::Form::UndestroyableObject.
+        # Also destroy performer block might be passed instead of in-class
+        # performer definition:
+        #
+        #   author.destroy { REDIS.del(id) }
+        #
+        def destroy(&block)
+          raise Granite::Form::UndestroyableObject unless block || destroyable?
+          destroy_object(&block)
+          self
+        end
+
+        # Destroys object by calling the destroy performer.
+        # In case of success returns instance and changes +persisted?+
+        # to false and +destroyed?+ to true.
+        # Raises Granite::Form::ObjectNotDestroyed in case of fail.
+        #
+        #   author.destroy!
+        #
+        # If destroy performer is not defined with `define_destroy`,
+        # it raises Granite::Form::UndestroyableObject.
+        # Also destroy performer block might be passed instead of in-class
+        # performer definition:
+        #
+        #   author.destroy! { REDIS.del(id) }
+        #
+        def destroy!(&block)
+          raise Granite::Form::UndestroyableObject unless block || destroyable?
+          destroy_object(&block) or raise Granite::Form::ObjectNotDestroyed
+          self
+        end
+
+      private
+
+        def savable?
+          !!((persisted? ? _update_performer : _create_performer) || _save_performer)
+        end
+
+        def save_object(&block)
+          apply_association_changes! if respond_to?(:apply_association_changes!)
+          result = persisted? ? update_object(&block) : create_object(&block)
+          mark_persisted! if result
+          result
+        end
+
+        def create_object(&block)
+          performer = block || _create_performer || _save_performer
+          !!performer_exec(&performer)
+        end
+
+        def update_object(&block)
+          performer = block || _update_performer || _save_performer
+          !!performer_exec(&performer)
+        end
+
+        def destroyable?
+          !!_destroy_performer
+        end
+
+        def destroy_object(&block)
+          performer = block || _destroy_performer
+          result = !!performer_exec(&performer)
+          mark_destroyed! if result
+          result
+        end
+
+        def performer_exec(&block)
+          if block.arity == 1
+            yield(self)
+          else
+            instance_exec(&block)
+          end
+        end
+      end
+    end
+  end
+end