granite-form 0.1.0

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

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes::Attribute do
+  before { stub_model(:dummy) }
+
+  def attribute(*args)
+    options = args.extract_options!
+    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Attribute, :field, {type: Object}.merge(options))
+    Dummy.new.attribute(:field)
+  end
+
+  describe '#read' do
+    let(:field) { attribute(type: String, normalizer: ->(v) { v ? v.strip : v }, default: :world, enum: %w[hello 42 world]) }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read).to eq('world') }
+    specify { expect(field.tap { |r| r.write(:world) }.read).to eq('world') }
+    specify { expect(field.tap { |r| r.write('hello') }.read).to eq('hello') }
+    specify { expect(field.tap { |r| r.write(' hello ') }.read).to eq(nil) }
+    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('') }.read).to eq(nil) }
+
+    context ':readonly' do
+      specify { expect(attribute(readonly: true, default: :world).tap { |r| r.write('string') }.read).to eq(:world) }
+    end
+  end
+
+  describe '#read_before_type_cast' do
+    let(:field) { attribute(type: String, normalizer: ->(v) { v.strip }, default: :world, enum: %w[hello 42 world]) }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq(:world) }
+    specify { expect(field.tap { |r| r.write(:world) }.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('') }.read_before_type_cast).to eq('') }
+
+    context ':readonly' do
+      specify { expect(attribute(readonly: true, default: :world).tap { |r| r.write('string') }.read_before_type_cast).to eq(:world) }
+    end
+  end
+
+  describe '#default' do
+    before { allow_any_instance_of(Dummy).to receive_messages(value: 42) }
+
+    specify { expect(attribute.default).to eq(nil) }
+    specify { expect(attribute(default: 'hello').default).to eq('hello') }
+    specify { expect(attribute(default: -> { value }).default).to eq(42) }
+    specify { expect(attribute(default: ->(object) { object.value }).default).to eq(42) }
+    specify { expect(attribute(default: ->(*args) { args.first.value }).default).to eq(42) }
+  end
+
+  describe '#defaultize' do
+    specify { expect(attribute.defaultize(nil)).to be_nil }
+    specify { expect(attribute(default: 'hello').defaultize(nil)).to eq('hello') }
+    specify { expect(attribute(default: 'hello').defaultize('world')).to eq('world') }
+    specify { expect(attribute(default: false, type: Boolean).defaultize(nil)).to eq(false) }
+  end
+
+  describe '#typecast' do
+    context 'when Object' do
+      specify { expect(attribute.typecast(:hello)).to eq(:hello) }
+    end
+
+    context 'when Integer' do
+      specify { expect(attribute(type: Integer).typecast(42)).to eq(42) }
+      specify { expect(attribute(type: Integer).typecast('42')).to eq(42) }
+    end
+
+    context 'when Hash' do
+      let(:to_h) { {'x' => {'foo' => 'bar'}, 'y' => 2} }
+      let(:parameters) { ActionController::Parameters.new(to_h) }
+
+      before(:all) do
+        @default_hash_typecaster = Granite::Form.typecaster('Hash')
+        require 'action_controller'
+        Class.new(ActionController::Base)
+        @action_controller_hash_typecaster = Granite::Form.typecaster('Hash')
+      end
+
+      context 'when ActionController is loaded' do
+        before { Granite::Form.typecaster('Hash', &@action_controller_hash_typecaster) }
+        after { Granite::Form.typecaster('Hash', &@default_hash_typecaster) }
+
+        specify { expect(attribute(type: Hash).typecast(nil)).to be_nil }
+        specify { expect(attribute(type: Hash).typecast(to_h)).to eq(to_h) }
+        specify { expect(attribute(type: Hash).typecast(parameters)).to be_nil }
+        specify { expect(attribute(type: Hash).typecast(parameters.permit(:y, x: [:foo]))).to eq(to_h) }
+      end
+
+      context 'when ActionController is not loaded' do
+        before { Granite::Form.typecaster('Hash', &@default_hash_typecaster) }
+
+        specify { expect(attribute(type: Hash).typecast(nil)).to be_nil }
+        specify { expect(attribute(type: Hash).typecast(to_h)).to eq(to_h) }
+        if ActiveSupport.version > Gem::Version.new('4.3')
+          specify { expect(attribute(type: Hash).typecast(parameters.permit(:y, x: [:foo]))).to be_nil }
+        else
+          specify { expect(attribute(type: Hash).typecast(parameters.permit(:y, x: [:foo]))).to eq(to_h) }
+        end
+      end
+    end
+  end
+
+  describe '#enum' do
+    before { allow_any_instance_of(Dummy).to receive_messages(value: 1..5) }
+
+    specify { expect(attribute.enum).to eq([].to_set) }
+    specify { expect(attribute(enum: []).enum).to eq([].to_set) }
+    specify { expect(attribute(enum: 'hello').enum).to eq(['hello'].to_set) }
+    specify { expect(attribute(enum: %w[hello world]).enum).to eq(%w[hello world].to_set) }
+    specify { expect(attribute(enum: [1..5]).enum).to eq([1..5].to_set) }
+    specify { expect(attribute(enum: 1..5).enum).to eq((1..5).to_a.to_set) }
+    specify { expect(attribute(enum: -> { 1..5 }).enum).to eq((1..5).to_a.to_set) }
+    specify { expect(attribute(enum: -> { 'hello' }).enum).to eq(['hello'].to_set) }
+    specify { expect(attribute(enum: -> { ['hello', 42] }).enum).to eq(['hello', 42].to_set) }
+    specify { expect(attribute(enum: -> { value }).enum).to eq((1..5).to_a.to_set) }
+    specify { expect(attribute(enum: ->(object) { object.value }).enum).to eq((1..5).to_a.to_set) }
+  end
+
+  describe '#enumerize' do
+    specify { expect(attribute.enumerize('anything')).to eq('anything') }
+    specify { expect(attribute(enum: ['hello', 42]).enumerize('hello')).to eq('hello') }
+    specify { expect(attribute(enum: ['hello', 42]).enumerize('world')).to eq(nil) }
+    specify { expect(attribute(enum: -> { 'hello' }).enumerize('hello')).to eq('hello') }
+    specify { expect(attribute(enum: -> { 1..5 }).enumerize(2)).to eq(2) }
+    specify { expect(attribute(enum: -> { 1..5 }).enumerize(42)).to eq(nil) }
+  end
+
+  describe '#normalize' do
+    specify { expect(attribute.normalize(' hello ')).to eq(' hello ') }
+    specify { expect(attribute(normalizer: ->(v) { v.strip }).normalize(' hello ')).to eq('hello') }
+    specify { expect(attribute(normalizer: [->(v) { v.strip }, ->(v) { v.first(4) }]).normalize(' hello ')).to eq('hell') }
+    specify { expect(attribute(normalizer: [->(v) { v.first(4) }, ->(v) { v.strip }]).normalize(' hello ')).to eq('hel') }
+
+    context do
+      before { allow_any_instance_of(Dummy).to receive_messages(value: 'value') }
+      let(:other) { 'other' }
+
+      specify { expect(attribute(normalizer: ->(_v) { value }).normalize(' hello ')).to eq('value') }
+      specify { expect(attribute(normalizer: ->(_v, object) { object.value }).normalize(' hello ')).to eq('value') }
+      specify { expect(attribute(normalizer: ->(_v, _object) { other }).normalize(' hello ')).to eq('other') }
+    end
+
+    context 'integration' do
+      before do
+        allow(Granite::Form).to receive_messages(config: Granite::Form::Config.send(:new))
+        Granite::Form.normalizer(:strip) { |value, _, _| value.strip }
+        Granite::Form.normalizer(:trim) do |value, options, _attribute|
+          value.first(length || options[:length] || 2)
+        end
+        Granite::Form.normalizer(:reset) do |value, _options, attribute|
+          empty = value.respond_to?(:empty?) ? value.empty? : value.nil?
+          empty ? attribute.default : value
+        end
+      end
+
+      let(:length) { nil }
+
+      specify { expect(attribute(normalizer: :strip).normalize(' hello ')).to eq('hello') }
+      specify { expect(attribute(normalizer: %i[strip trim]).normalize(' hello ')).to eq('he') }
+      specify { expect(attribute(normalizer: %i[trim strip]).normalize(' hello ')).to eq('h') }
+      specify { expect(attribute(normalizer: [:strip, {trim: {length: 4}}]).normalize(' hello ')).to eq('hell') }
+      specify { expect(attribute(normalizer: {strip: {}, trim: {length: 4}}).normalize(' hello ')).to eq('hell') }
+      specify do
+        expect(attribute(normalizer: [:strip, {trim: {length: 4}}, ->(v) { v.last(2) }])
+        .normalize(' hello ')).to eq('ll')
+      end
+      specify { expect(attribute(normalizer: :reset).normalize('')).to eq(nil) }
+      specify { expect(attribute(normalizer: %i[strip reset]).normalize('   ')).to eq(nil) }
+      specify { expect(attribute(normalizer: :reset, default: '!!!').normalize(nil)).to eq('!!!') }
+      specify { expect(attribute(normalizer: :reset, default: '!!!').normalize('')).to eq('!!!') }
+
+      context do
+        let(:length) { 3 }
+
+        specify { expect(attribute(normalizer: [:strip, {trim: {length: 4}}]).normalize(' hello ')).to eq('hel') }
+        specify { expect(attribute(normalizer: {strip: {}, trim: {length: 4}}).normalize(' hello ')).to eq('hel') }
+        specify do
+          expect(attribute(normalizer: [:strip, {trim: {length: 4}}, ->(v) { v.last(2) }])
+          .normalize(' hello ')).to eq('el')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes::Base do
+  before { stub_model(:dummy) }
+
+  def attribute(*args)
+    options = args.extract_options!
+    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Base, :field, options)
+    Dummy.new.attribute(:field)
+  end
+
+  describe '#read' do
+    let(:field) { attribute(type: String, normalizer: ->(v) { v ? v.strip : v }, default: :world, enum: %w[hello 42 world]) }
+    let(:object) { Object.new }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read).to be_nil }
+    specify { expect(field.tap { |r| r.write('') }.read).to eq('') }
+    specify { expect(field.tap { |r| r.write(:world) }.read).to eq(:world) }
+    specify { expect(field.tap { |r| r.write(object) }.read).to eq(object) }
+
+    context ':readonly' do
+      specify { expect(attribute(readonly: true).tap { |r| r.write('string') }.read).to be_nil }
+    end
+  end
+
+  describe '#read_before_type_cast' do
+    let(:field) { attribute(type: String, normalizer: ->(v) { v.strip }, default: :world, enum: %w[hello 42 world]) }
+    let(:object) { Object.new }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to be_nil }
+    specify { expect(field.tap { |r| r.write('') }.read_before_type_cast).to eq('') }
+    specify { expect(field.tap { |r| r.write(:world) }.read_before_type_cast).to eq(:world) }
+    specify { expect(field.tap { |r| r.write(object) }.read_before_type_cast).to eq(object) }
+
+    context ':readonly' do
+      specify { expect(attribute(readonly: true).tap { |r| r.write('string') }.read_before_type_cast).to be_nil }
+    end
+  end
+
+  describe '#came_from_user?' do
+    let(:field) { attribute(type: String, default: 'world') }
+    let(:object) { Object.new }
+
+    specify { expect(field.came_from_user?).to eq(false) }
+    specify { expect(field.tap { |r| r.write('value') }.came_from_user?).to eq(true) }
+  end
+
+  describe '#came_from_default?' do
+    let(:field) { attribute(type: String, default: 'world') }
+    let(:object) { Object.new }
+
+    specify { expect(field.came_from_default?).to eq(true) }
+    specify { expect(field.tap { |r| r.write('value') }.came_from_default?).to eq(false) }
+  end
+
+  describe '#value_present?' do
+    let(:field) { attribute }
+
+    specify { expect(field.tap { |r| r.write(0) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write(42) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write(true) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write(false) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write(nil) }).not_to be_value_present }
+    specify { expect(field.tap { |r| r.write('') }).not_to be_value_present }
+    specify { expect(field.tap { |r| r.write(:world) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write(Object.new) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write([]) }).not_to be_value_present }
+    specify { expect(field.tap { |r| r.write([42]) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write({}) }).not_to be_value_present }
+    specify { expect(field.tap { |r| r.write(hello: 42) }).to be_value_present }
+  end
+
+  describe '#query' do
+    let(:field) { attribute }
+
+    specify { expect(field.tap { |r| r.write(0) }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write(42) }.query).to be(true) }
+    specify { expect(field.tap { |r| r.write(true) }.query).to be(true) }
+    specify { expect(field.tap { |r| r.write(false) }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write(nil) }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write('') }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write(:world) }.query).to be(true) }
+    specify { expect(field.tap { |r| r.write(Object.new) }.query).to be(true) }
+    specify { expect(field.tap { |r| r.write([]) }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write([42]) }.query).to be(true) }
+    specify { expect(field.tap { |r| r.write({}) }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write(hello: 42) }.query).to be(true) }
+  end
+
+  describe '#readonly?' do
+    specify { expect(attribute).not_to be_readonly }
+    specify { expect(attribute(readonly: false)).not_to be_readonly }
+    specify { expect(attribute(readonly: true)).to be_readonly }
+    specify { expect(attribute(readonly: -> { false })).not_to be_readonly }
+    specify { expect(attribute(readonly: -> { true })).to be_readonly }
+  end
+end

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

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

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

@@ -0,0 +1,100 @@
+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/lib/granite/form/model/attributes/localized_spec.rb

@@ -0,0 +1,103 @@
+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)
+    described_class.new('field', Dummy.new)
+  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/lib/granite/form/model/attributes/reflections/attribute_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes::Reflections::Attribute do
+  def reflection(options = {})
+    described_class.new(:field, options)
+  end
+
+  describe '.build' do
+    before { stub_class(:target) }
+
+    specify { expect(described_class.build(Class.new, Target, :field, String).type).to eq(String) }
+    specify { expect(described_class.build(Class.new, Target, :field) {}.defaultizer).to be_a(Proc) }
+    specify do
+      described_class.build(Class.new, Target, :field)
+
+      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)
+      expect(Target).to be_method_defined(:field_default)
+      expect(Target).to be_method_defined(:field_values)
+    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)
+      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)
+      expect(Target).to be_method_defined(:field_alias_default)
+      expect(Target).to be_method_defined(:field_alias_values)
+    end
+  end
+
+  describe '#defaultizer' do
+    specify { expect(reflection.defaultizer).to be_nil }
+    specify { expect(reflection(default: 42).defaultizer).to eq(42) }
+    specify { expect(reflection(default: -> {}).defaultizer).to be_a Proc }
+  end
+
+  describe '#typecaster' do
+    before do
+      stub_class(:dummy, String)
+      stub_class(:dummy_dummy, Dummy)
+    end
+
+    specify { expect(reflection(type: Object).typecaster).to eq(Granite::Form.typecaster(Object)) }
+    specify { expect(reflection(type: String).typecaster).to eq(Granite::Form.typecaster(String)) }
+    specify { expect(reflection(type: Dummy).typecaster).to eq(Granite::Form.typecaster(String)) }
+    specify { expect(reflection(type: DummyDummy).typecaster).to eq(Granite::Form.typecaster(String)) }
+  end
+
+  describe '#enumerizer' do
+    specify { expect(reflection.enumerizer).to be_nil }
+    specify { expect(reflection(enum: 42).enumerizer).to eq(42) }
+    specify { expect(reflection(enum: -> {}).enumerizer).to be_a Proc }
+    specify { expect(reflection(in: 42).enumerizer).to eq(42) }
+    specify { expect(reflection(in: -> {}).enumerizer).to be_a Proc }
+    specify { expect(reflection(enum: 42, in: -> {}).enumerizer).to eq(42) }
+  end
+
+  describe '#normalizers' do
+    specify { expect(reflection.normalizers).to eq([]) }
+    specify { expect(reflection(normalizer: -> {}).normalizers).to be_a Array }
+    specify { expect(reflection(normalizer: -> {}).normalizers.first).to be_a Proc }
+  end
+end