granite-form 0.3.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