granite-form 0.2.0 → 0.4.0

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

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-describe Granite::Form::Model::Attributes::Dictionary do
-  before { stub_model(:dummy) }
-
-  def attribute(*args)
-    options = args.extract_options!
-    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Dictionary, :field, options)
-    Dummy.new.attribute(:field)
-  end
-
-  describe '#read' do
-    let(:field) do
-      attribute(type: String,
-      normalizer: ->(val) { val.delete_if { |_, v| v.nil? } },
-      default: :world, enum: %w[hello 42])
-    end
-
-    specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write(a: nil) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write(a: '') }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write(a: 1) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write(a: 42) }.read).to eq('a' => '42') }
-    specify { expect(field.tap { |r| r.write(a: 'hello', b: '42') }.read).to eq('a' => 'hello', 'b' => '42') }
-    specify { expect(field.tap { |r| r.write(a: 'hello', b: '1') }.read).to eq('a' => 'hello') }
-    specify { expect(field.tap { |r| r.write(a: 'hello', x: '42') }.read).to eq('a' => 'hello', 'x' => '42') }
-
-    context do
-      let(:field) do
-        attribute(type: String,
-        normalizer: ->(val) { val.delete_if { |_, v| v.nil? } },
-        default: :world)
-      end
-
-      specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write(a: 1) }.read).to eq('a' => '1') }
-      specify { expect(field.tap { |r| r.write(a: nil, b: nil) }.read).to eq('a' => 'world', 'b' => 'world') }
-      specify { expect(field.tap { |r| r.write(a: '') }.read).to eq('a' => '') }
-    end
-
-    context 'with :keys' do
-      let(:field) { attribute(type: String, keys: ['a', :b]) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write(a: 1, 'b' => 2, c: 3, 'd' => 4) }.read).to eq('a' => '1', 'b' => '2') }
-      specify { expect(field.tap { |r| r.write(a: 1, c: 3, 'd' => 4) }.read).to eq('a' => '1') }
-    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({}) }.read_before_type_cast).to eq({}) }
-    specify { expect(field.tap { |r| r.write(a: 1) }.read_before_type_cast).to eq('a' => 1) }
-    specify { expect(field.tap { |r| r.write(a: nil) }.read_before_type_cast).to eq('a' => :world) }
-    specify { expect(field.tap { |r| r.write(a: '') }.read_before_type_cast).to eq('a' => '') }
-    specify { expect(field.tap { |r| r.write(a: 42) }.read_before_type_cast).to eq('a' => 42) }
-    specify { expect(field.tap { |r| r.write(a: 'hello', b: '42') }.read_before_type_cast).to eq('a' => 'hello', 'b' => '42') }
-    specify { expect(field.tap { |r| r.write(a: 'hello', b: '1') }.read_before_type_cast).to eq('a' => 'hello', 'b' => '1') }
-    specify { expect(field.tap { |r| r.write(a: 'hello', x: '42') }.read_before_type_cast).to eq('a' => 'hello', 'x' => '42') }
-
-    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({}) }.read_before_type_cast).to eq({}) }
-      specify { expect(field.tap { |r| r.write(a: 1) }.read_before_type_cast).to eq('a' => 1) }
-      specify { expect(field.tap { |r| r.write(a: nil, b: nil) }.read_before_type_cast).to eq('a' => :world, 'b' => :world) }
-      specify { expect(field.tap { |r| r.write(a: '') }.read_before_type_cast).to eq('a' => '') }
-    end
-
-    context 'with :keys' do
-      let(:field) { attribute(type: String, keys: ['a', :b]) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
-      specify { expect(field.tap { |r| r.write({}) }.read_before_type_cast).to eq({}) }
-      specify do
-        expect(field.tap { |r| r.write(a: 1, 'b' => 2, c: 3, 'd' => 4) }.read_before_type_cast)
-          .to eq('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4)
-      end
-    end
-  end
-
-  context 'integration' do
-    before do
-      stub_model(:post) do
-        dictionary :options, type: String
-      end
-    end
-
-    specify { expect(Post.new(options: {a: 'hello', b: 42}).options).to eq('a' => 'hello', 'b' => '42') }
-    specify { expect(Post.new(options: {a: 'hello', b: 42}).options_before_type_cast).to eq('a' => 'hello', 'b' => 42) }
-    specify { expect(Post.new.options?).to eq(false) }
-    specify { expect(Post.new(options: {a: 'hello', b: 42}).options?).to eq(true) }
-  end
-end

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

@@ -1,103 +0,0 @@
-require 'spec_helper'
-
-describe Granite::Form::Model::Attributes::Localized do
-  before { stub_model(:dummy) }
-
-  def attribute(*args)
-    options = args.extract_options!
-    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Localized, :field, options)
-    Dummy.new.attribute(:field)
-  end
-
-  describe '#read' do
-    let(:field) { attribute(type: String, default: :world, enum: %w[hello 42]) }
-
-    specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write(en: 'hello') }.read).to eq('en' => 'hello') }
-    specify { expect(field.tap { |r| r.write(en: 42) }.read).to eq('en' => '42') }
-    specify { expect(field.tap { |r| r.write(en: 43) }.read).to eq('en' => nil) }
-    specify { expect(field.tap { |r| r.write(en: '') }.read).to eq('en' => nil) }
-    specify { expect(field.tap { |r| r.write(en: nil) }.read).to eq('en' => nil) }
-    specify { expect(field.tap { |r| r.write(en: 'hello', ru: 42) }.read).to eq('en' => 'hello', 'ru' => '42') }
-
-    context do
-      let(:field) { attribute(type: String, default: :world) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write(en: 'hello') }.read).to eq('en' => 'hello') }
-      specify { expect(field.tap { |r| r.write(en: 42) }.read).to eq('en' => '42') }
-      specify { expect(field.tap { |r| r.write(en: '') }.read).to eq('en' => '') }
-      specify { expect(field.tap { |r| r.write(en: nil) }.read).to eq('en' => 'world') }
-    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(en: 'hello') }.read_before_type_cast).to eq('en' => 'hello') }
-    specify { expect(field.tap { |r| r.write(en: 42) }.read_before_type_cast).to eq('en' => 42) }
-    specify { expect(field.tap { |r| r.write(en: 43) }.read_before_type_cast).to eq('en' => 43) }
-    specify { expect(field.tap { |r| r.write(en: '') }.read_before_type_cast).to eq('en' => '') }
-    specify { expect(field.tap { |r| r.write(en: nil) }.read_before_type_cast).to eq('en' => :world) }
-    specify { expect(field.tap { |r| r.write(en: 'hello', ru: 42) }.read_before_type_cast).to eq('en' => 'hello', 'ru' => 42) }
-
-    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(en: 'hello') }.read_before_type_cast).to eq('en' => 'hello') }
-      specify { expect(field.tap { |r| r.write(en: 42) }.read_before_type_cast).to eq('en' => 42) }
-      specify { expect(field.tap { |r| r.write(en: '') }.read_before_type_cast).to eq('en' => '') }
-      specify { expect(field.tap { |r| r.write(en: nil) }.read_before_type_cast).to eq('en' => :world) }
-    end
-  end
-
-  context 'integration' do
-    let(:klass) do
-      Class.new do
-        include Granite::Form::Model
-        include Granite::Form::Model::Localization
-
-        localized :name, type: String
-      end
-    end
-    let(:translations) { {en: 'Hello', ru: 'Привет'} }
-    before { I18n.locale = :en }
-
-    describe '#name_translations' do
-      subject { klass.new name_translations: translations }
-      its(:name_translations) { should == translations.stringify_keys }
-      its(:name) { should == translations[:en] }
-    end
-
-    describe '#name' do
-      subject { klass.new name: 'Hello' }
-      its(:name_translations) { should == {'en' => 'Hello'} }
-      its(:name) { should == 'Hello' }
-    end
-
-    describe '#name_before_type_cast' do
-      let(:object) { Object.new }
-      subject { klass.new name: object }
-      its(:name_before_type_cast) { should == object }
-    end
-
-    context 'fallbacks' do
-      subject { klass.new name_translations: {ru: 'Привет'} }
-      context do
-        its(:name) { should be_nil }
-      end
-
-      context do
-        before do
-          require 'i18n/backend/fallbacks'
-          I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
-          I18n.fallbacks[:en] = [:ru]
-        end
-        after { I18n.fallbacks = false }
-        its(:name) { should == 'Привет' }
-      end
-    end
-  end
-end

data/spec/granite/form/model/attributes/reflections/localized_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe Granite::Form::Model::Attributes::Reflections::Localized do
-  def reflection(options = {})
-    described_class.new(:field, options)
-  end
-
-  describe '.build' do
-    before { stub_class(:target) }
-
-    specify do
-      described_class.build(Class.new, Target, :field)
-
-      expect(Target).to be_method_defined(:field_translations)
-      expect(Target).to be_method_defined(:field_translations=)
-      expect(Target).to be_method_defined(:field)
-      expect(Target).to be_method_defined(:field=)
-      expect(Target).to be_method_defined(:field?)
-      expect(Target).to be_method_defined(:field_before_type_cast)
-    end
-  end
-
-  describe '#generate_methods' do
-    before { stub_class(:target) }
-
-    specify do
-      described_class.generate_methods(:field_alias, Target)
-
-      expect(Target).to be_method_defined(:field_alias_translations)
-      expect(Target).to be_method_defined(:field_alias_translations=)
-      expect(Target).to be_method_defined(:field_alias)
-      expect(Target).to be_method_defined(:field_alias=)
-      expect(Target).to be_method_defined(:field_alias?)
-      expect(Target).to be_method_defined(:field_alias_before_type_cast)
-    end
-  end
-end

data/spec/granite/form/model/callbacks_spec.rb

@@ -1,337 +0,0 @@
-require 'spec_helper'
-
-describe Granite::Form::Model::Callbacks do
-  before do
-    stub_model(:user) do
-      include Granite::Form::Model::Callbacks
-      attribute :actions, Array, default: []
-
-      def append(action)
-        self.actions = actions + [action]
-      end
-
-      define_create { append :create }
-      define_update { append :update }
-      define_destroy { append :destroy }
-    end
-  end
-
-  describe '.after_initialize' do
-    before do
-      User.after_initialize { append :after_initialize }
-    end
-
-    specify { expect(User.new.actions).to eq([:after_initialize]) }
-    specify { expect(User.create.actions).to eq(%i[after_initialize create]) }
-  end
-
-  describe '.before_save, .after_save' do
-    before do
-      User.before_save { append :before_save }
-      User.after_save { append :after_save }
-    end
-
-    specify { expect(User.create.actions).to eq(%i[before_save create after_save]) }
-    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_save create after_save]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_save create after_save]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_save create after_save before_save update after_save]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_save create after_save before_save update after_save]) }
-
-    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_save]) }
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[before_save create after_save before_save]) }
-  end
-
-  describe '.around_save' do
-    before do
-      User.around_save do |_, block|
-        append :before_around_save
-        block.call
-        append :after_around_save
-      end
-    end
-
-    specify { expect(User.create.actions).to eq(%i[before_around_save create after_around_save]) }
-    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_around_save create after_around_save]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_around_save create after_around_save]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_around_save create after_around_save before_around_save update after_around_save]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_around_save create after_around_save before_around_save update after_around_save]) }
-
-    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq(%i[before_around_save after_around_save]) }
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[before_around_save create after_around_save before_around_save after_around_save]) }
-  end
-
-  describe '.before_create, .after_create' do
-    before do
-      User.before_create { append :before_create }
-      User.after_create { append :after_create }
-    end
-
-    specify { expect(User.create.actions).to eq(%i[before_create create after_create]) }
-    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_create create after_create]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_create create after_create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_create create after_create update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_create create after_create update]) }
-
-    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_create]) }
-  end
-
-  describe '.around_create' do
-    before do
-      User.around_create do |_, block|
-        append :before_around_create
-        block.call
-        append :after_around_create
-      end
-    end
-
-    specify { expect(User.create.actions).to eq(%i[before_around_create create after_around_create]) }
-    specify { expect(User.new.tap(&:save).actions).to eq(%i[before_around_create create after_around_create]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq(%i[before_around_create create after_around_create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[before_around_create create after_around_create update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[before_around_create create after_around_create update]) }
-
-    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq(%i[before_around_create after_around_create]) }
-  end
-
-  describe '.before_update, .after_update' do
-    before do
-      User.before_update { append :before_update }
-      User.after_update { append :after_update }
-    end
-
-    specify { expect(User.create.actions).to eq([:create]) }
-    specify { expect(User.new.tap(&:save).actions).to eq([:create]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[create before_update update after_update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[create before_update update after_update]) }
-
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[create before_update]) }
-  end
-
-  describe '.around_update' do
-    before do
-      User.around_update do |_, block|
-        append :before_around_update
-        block.call
-        append :after_around_update
-      end
-    end
-
-    specify { expect(User.create.actions).to eq([:create]) }
-    specify { expect(User.new.tap(&:save).actions).to eq([:create]) }
-    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:create]) }
-    specify { expect(User.create.tap(&:save).actions).to eq(%i[create before_around_update update after_around_update]) }
-    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq(%i[create before_around_update update after_around_update]) }
-
-    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq(%i[create before_around_update after_around_update]) }
-  end
-
-  describe '.before_validation, .after_validation,
-            .before_save, .after_save, .around_save,
-            .before_create, .after_create, .around_create,
-            .before_update, .after_update, .around_update
-            .before_destroy, .after_destroy, .around_destroy' do
-    before do
-      User.before_validation { append :before_validation }
-      User.after_validation { append :after_validation }
-
-      User.before_save { append :before_save }
-      User.after_save { append :after_save }
-      User.around_save do |_, block|
-        append :before_around_save
-        block.call
-        append :after_around_save
-      end
-
-      User.before_create { append :before_create }
-      User.after_create { append :after_create }
-      User.around_create do |_, block|
-        append :before_around_create
-        block.call
-        append :after_around_create
-      end
-
-      User.before_update { append :before_update }
-      User.after_update { append :after_update }
-      User.around_update do |_, block|
-        append :before_around_update
-        block.call
-        append :after_around_update
-      end
-
-      User.before_destroy { append :before_destroy }
-      User.after_destroy { append :after_destroy }
-      User.around_destroy do |_, block|
-        append :before_around_destroy
-        block.call
-        append :after_around_destroy
-      end
-    end
-
-    specify do
-      expect(User.create.tap(&:save).destroy.actions).to eq(%i[
-        before_validation after_validation
-        before_save before_around_save
-        before_create before_around_create
-        create
-        after_around_create after_create
-        after_around_save after_save
-        before_validation after_validation
-        before_save before_around_save
-        before_update before_around_update
-        update
-        after_around_update after_update
-        after_around_save after_save
-        before_destroy before_around_destroy
-        destroy
-        after_around_destroy after_destroy
-      ])
-    end
-  end
-
-  describe '.before_destroy, .after_destroy' do
-    before do
-      User.before_destroy { append :before_destroy }
-      User.after_destroy { append :after_destroy }
-    end
-
-    specify { expect(User.new.destroy.actions).to eq(%i[before_destroy destroy after_destroy]) }
-    specify { expect(User.create.destroy.actions).to eq(%i[create before_destroy destroy after_destroy]) }
-
-    specify { expect(User.new.destroy { false }.actions).to eq([:before_destroy]) }
-    specify { expect(User.create.destroy { false }.actions).to eq(%i[create before_destroy]) }
-  end
-
-  describe '.around_destroy' do
-    before do
-      User.around_destroy do |_, block|
-        append :before_around_destroy
-        block.call
-        append :after_around_destroy
-      end
-    end
-
-    specify { expect(User.new.destroy.actions).to eq(%i[before_around_destroy destroy after_around_destroy]) }
-    specify { expect(User.create.destroy.actions).to eq(%i[create before_around_destroy destroy after_around_destroy]) }
-
-    specify { expect(User.new.destroy { false }.actions).to eq(%i[before_around_destroy after_around_destroy]) }
-    specify { expect(User.create.destroy { false }.actions).to eq(%i[create before_around_destroy after_around_destroy]) }
-  end
-
-  context 'unsavable, undestroyable' do
-    before do
-      stub_model(:user) do
-        include Granite::Form::Model::Callbacks
-
-        attribute :actions, Array, default: []
-        attribute :validated, Boolean, default: false
-
-        validates :validated, presence: true
-
-        def append(action)
-          self.actions = actions + [action]
-        end
-      end
-    end
-
-    before do
-      User.before_validation { append :before_validation }
-      User.after_validation { append :after_validation }
-
-      User.before_save { append :before_save }
-      User.after_save { append :after_save }
-      User.around_save do |&block|
-        append :before_around_save
-        block.call
-        append :after_around_save
-      end
-
-      User.before_create { append :before_create }
-      User.after_create { append :after_create }
-      User.around_create do |&block|
-        append :before_around_create
-        block.call
-        append :after_around_create
-      end
-
-      User.before_update { append :before_update }
-      User.after_update { append :after_update }
-      User.around_update do |&block|
-        append :before_around_update
-        block.call
-        append :after_around_update
-      end
-
-      User.before_destroy { append :before_destroy }
-      User.after_destroy { append :after_destroy }
-      User.around_destroy do |&block|
-        append :before_around_destroy
-        block.call
-        append :after_around_destroy
-      end
-    end
-
-    let(:user) { User.new }
-
-    specify do
-      begin
-        user.save
-      rescue Granite::Form::UnsavableObject
-        expect(user.actions).to eq([])
-      end
-    end
-
-    specify do
-      begin
-        user.save!
-      rescue Granite::Form::UnsavableObject
-        expect(user.actions).to eq([])
-      end
-    end
-
-    specify do
-      user.save { true }
-      expect(user.actions).to eq(%i[before_validation after_validation])
-    end
-
-    specify do
-      begin
-        user.save! { true }
-      rescue Granite::Form::ValidationError
-        expect(user.actions).to eq(%i[before_validation after_validation])
-      end
-    end
-
-    specify do
-      begin
-        user.update({})
-      rescue Granite::Form::UnsavableObject
-        expect(user.actions).to eq([])
-      end
-    end
-
-    specify do
-      begin
-        user.update!({})
-      rescue Granite::Form::UnsavableObject
-        expect(user.actions).to eq([])
-      end
-    end
-
-    specify do
-      begin
-        user.destroy
-      rescue Granite::Form::UndestroyableObject
-        expect(user.actions).to eq([])
-      end
-    end
-
-    specify do
-      begin
-        user.destroy!
-      rescue Granite::Form::UndestroyableObject
-        expect(user.actions).to eq([])
-      end
-    end
-  end
-end