granite-form 0.2.0 → 0.4.0

data/gemfiles/rails.4.2.gemfile

@@ -1,15 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "activesupport", "~> 4.2.0"
-gem "activemodel", "~> 4.2.0"
-gem "activerecord", "~> 4.2.0"
-gem "sqlite3", "~> 1.3.6"
-
-group :test do
-  gem "guard"
-  gem "guard-rspec"
-end
-
-gemspec path: "../"

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

@@ -1,19 +0,0 @@
-module Granite
-  module Form
-    module Model
-      module Attributes
-        class Collection < Attribute
-          def read
-            @value ||= normalize(read_before_type_cast.map do |value|
-              enumerize(type_definition.ensure_type(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

@@ -1,28 +0,0 @@
-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(type_definition.ensure_type(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

@@ -1,44 +0,0 @@
-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(type_definition.ensure_type(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/reflections/localized.rb

@@ -1,45 +0,0 @@
-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/callbacks.rb

@@ -1,72 +0,0 @@
-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/lifecycle.rb

@@ -1,309 +0,0 @@
-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

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

@@ -1,26 +0,0 @@
-require 'granite/form/model/attributes/reflections/localized'
-require 'granite/form/model/attributes/localized'
-
-module Granite
-  module Form
-    module Model
-      module Localization
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def localized(*args, &block)
-            add_attribute(Granite::Form::Model::Attributes::Reflections::Localized, *args, &block)
-          end
-
-          def fallbacks(locale)
-            ::I18n.respond_to?(:fallbacks) ? ::I18n.fallbacks[locale] : [locale]
-          end
-
-          def locale
-            I18n.locale
-          end
-        end
-      end
-    end
-  end
-end

data/spec/granite/form/model/attributes/collection_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-describe Granite::Form::Model::Attributes::Collection do
-  before { stub_model(:dummy) }
-
-  def attribute(*args)
-    options = args.extract_options!
-    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Collection, :field, options)
-    Dummy.new.attribute(:field)
-  end
-
-  describe '#read' do
-    let(:field) { attribute(type: String, normalizer: ->(v) { v.uniq }, default: :world, enum: %w[hello 42]) }
-
-    specify { expect(field.tap { |r| r.write(nil) }.read).to eq([]) }
-    specify { expect(field.tap { |r| r.write([nil]) }.read).to eq([nil]) }
-    specify { expect(field.tap { |r| r.write('hello') }.read).to eq(['hello']) }
-    specify { expect(field.tap { |r| r.write([42]) }.read).to eq(['42']) }
-    specify { expect(field.tap { |r| r.write([43]) }.read).to eq([nil]) }
-    specify { expect(field.tap { |r| r.write([43, 44]) }.read).to eq([nil]) }
-    specify { expect(field.tap { |r| r.write(['']) }.read).to eq([nil]) }
-    specify { expect(field.tap { |r| r.write(['hello', 42]) }.read).to eq(%w[hello 42]) }
-    specify { expect(field.tap { |r| r.write(['hello', false]) }.read).to eq(['hello', nil]) }
-
-    context do
-      let(:field) { attribute(type: String, normalizer: ->(v) { v.uniq }, default: :world) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read).to eq([]) }
-      specify { expect(field.tap { |r| r.write([nil, nil]) }.read).to eq(['world']) }
-      specify { expect(field.tap { |r| r.write('hello') }.read).to eq(['hello']) }
-      specify { expect(field.tap { |r| r.write([42]) }.read).to eq(['42']) }
-      specify { expect(field.tap { |r| r.write(['']) }.read).to eq(['']) }
-    end
-  end
-
-  describe '#read_before_type_cast' do
-    let(:field) { attribute(type: String, default: :world, enum: %w[hello 42]) }
-
-    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq([]) }
-    specify { expect(field.tap { |r| r.write([nil]) }.read_before_type_cast).to eq([:world]) }
-    specify { expect(field.tap { |r| r.write('hello') }.read_before_type_cast).to eq(['hello']) }
-    specify { expect(field.tap { |r| r.write([42]) }.read_before_type_cast).to eq([42]) }
-    specify { expect(field.tap { |r| r.write([43]) }.read_before_type_cast).to eq([43]) }
-    specify { expect(field.tap { |r| r.write([43, 44]) }.read_before_type_cast).to eq([43, 44]) }
-    specify { expect(field.tap { |r| r.write(['']) }.read_before_type_cast).to eq(['']) }
-    specify { expect(field.tap { |r| r.write(['hello', 42]) }.read_before_type_cast).to eq(['hello', 42]) }
-    specify { expect(field.tap { |r| r.write(['hello', false]) }.read_before_type_cast).to eq(['hello', false]) }
-
-    context do
-      let(:field) { attribute(type: String, default: :world) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq([]) }
-      specify { expect(field.tap { |r| r.write([nil, nil]) }.read_before_type_cast).to eq(%i[world world]) }
-      specify { expect(field.tap { |r| r.write('hello') }.read_before_type_cast).to eq(['hello']) }
-      specify { expect(field.tap { |r| r.write([42]) }.read_before_type_cast).to eq([42]) }
-      specify { expect(field.tap { |r| r.write(['']) }.read_before_type_cast).to eq(['']) }
-    end
-  end
-
-  context 'integration' do
-    before do
-      stub_model(:post) do
-        collection :tags, String
-      end
-    end
-
-    specify { expect(Post.new(tags: ['hello', 42]).tags).to eq(%w[hello 42]) }
-    specify { expect(Post.new(tags: ['hello', 42]).tags_before_type_cast).to eq(['hello', 42]) }
-    specify { expect(Post.new.tags?).to eq(false) }
-    specify { expect(Post.new(tags: ['hello', 42]).tags?).to eq(true) }
-  end
-end