granite-form 0.1.1 → 0.3.0

data/spec/granite/form/model/associations/references_one_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Associations::ReferencesOne do
+  before do
+    stub_class(:author, ActiveRecord::Base) do
+      validates :name, presence: true
+    end
+
+    stub_model(:book) do
+      include Granite::Form::Model::Persistence
+      include Granite::Form::Model::Associations
+
+      attribute :title, String
+      references_one :author
+    end
+  end
+
+  let(:author) { Author.create!(name: 'Johny') }
+  let(:other) { Author.create!(name: 'Other') }
+  let(:book) { Book.new }
+  let(:association) { book.association(:author) }
+
+  let(:existing_book) { Book.instantiate title: 'My Life', author_id: author.id }
+  let(:existing_association) { existing_book.association(:author) }
+
+  describe 'book#association' do
+    specify { expect(association).to be_a described_class }
+    specify { expect(association).to eq(book.association(:author)) }
+  end
+
+  describe 'book#inspect' do
+    specify { expect(existing_book.inspect).to eq(<<~STR.chomp) }
+      #<Book author: #<ReferencesOne #{author.inspect}>, title: "My Life", author_id: #{author.id}>
+    STR
+  end
+
+  describe '#target' do
+    specify { expect(association.target).to be_nil }
+    specify { expect(existing_association.target).to eq(existing_book.author) }
+  end
+
+  describe '#loaded?' do
+    let(:new_author) { Author.create(name: 'Morty') }
+
+    specify { expect(association.loaded?).to eq(false) }
+    specify { expect { association.target }.to change { association.loaded? }.to(true) }
+    specify { expect { association.replace(new_author) }.to change { association.loaded? }.to(true) }
+    specify { expect { association.replace(nil) }.to change { association.loaded? }.to(true) }
+    specify { expect { existing_association.replace(new_author) }.to change { existing_association.loaded? }.to(true) }
+    specify { expect { existing_association.replace(nil) }.to change { existing_association.loaded? }.to(true) }
+  end
+
+  describe '#reload' do
+    specify { expect(association.reload).to be_nil }
+
+    specify { expect(existing_association.reload).to be_a Author }
+    specify { expect(existing_association.reload).to be_persisted }
+
+    context do
+      before { existing_association.reader.name = 'New' }
+      specify do
+        expect { existing_association.reload }
+          .to change { existing_association.reader.name }
+          .from('New').to('Johny')
+      end
+    end
+  end
+
+  describe '#reader' do
+    specify { expect(association.reader).to be_nil }
+
+    specify { expect(existing_association.reader).to be_a Author }
+    specify { expect(existing_association.reader).to be_persisted }
+  end
+
+  describe '#default' do
+    before { Book.references_one :author, default: ->(_book) { author.id } }
+    let(:existing_book) { Book.instantiate title: 'My Life' }
+
+    specify { expect(association.target).to eq(author) }
+    specify { expect { association.replace(other) }.to change { association.target }.to(other) }
+    specify { expect { association.replace(nil) }.to change { association.target }.to be_nil }
+
+    specify { expect(existing_association.target).to be_nil }
+    specify { expect { existing_association.replace(other) }.to change { existing_association.target }.to(other) }
+    specify { expect { existing_association.replace(nil) }.not_to change { existing_association.target } }
+  end
+
+  describe '#writer' do
+    context 'new owner' do
+      let(:new_author) { Author.new(name: 'Morty') }
+
+      let(:book) do
+        Book.new.tap do |book|
+          book.send(:mark_persisted!)
+        end
+      end
+
+      specify do
+        expect { association.writer(nil) }
+          .not_to change { book.author_id }
+      end
+      specify do
+        expect { association.writer(new_author) }
+          .to change { muffle(NoMethodError) { association.reader.name } }
+          .from(nil).to('Morty')
+      end
+      specify do
+        expect { association.writer(new_author) }
+          .not_to change { book.author_id }.from(nil)
+      end
+    end
+
+    context 'persisted owner' do
+      let(:new_author) { Author.create!(name: 'Morty') }
+
+      specify do
+        expect { association.writer(stub_model(:dummy).new) }
+          .to raise_error Granite::Form::AssociationTypeMismatch
+      end
+
+      specify { expect(association.writer(nil)).to be_nil }
+      specify { expect(association.writer(new_author)).to eq(new_author) }
+      specify do
+        expect { association.writer(nil) }
+          .not_to change { book.read_attribute(:author_id) }
+      end
+      specify do
+        expect { association.writer(new_author) }
+          .to change { association.reader.try(:attributes) }.from(nil).to('id' => new_author.id, 'name' => 'Morty')
+      end
+      specify do
+        expect { association.writer(new_author) }
+          .to change { book.read_attribute(:author_id) }
+      end
+
+      context do
+        before do
+          stub_class(:dummy, ActiveRecord::Base) do
+            self.table_name = :authors
+          end
+        end
+
+        specify do
+          expect { muffle(Granite::Form::AssociationTypeMismatch) { existing_association.writer(Dummy.new) } }
+            .not_to change { existing_book.read_attribute(:author_id) }
+        end
+        specify do
+          expect { muffle(Granite::Form::AssociationTypeMismatch) { existing_association.writer(Dummy.new) } }
+            .not_to change { existing_association.reader }
+        end
+      end
+
+      specify { expect(existing_association.writer(nil)).to be_nil }
+      specify { expect(existing_association.writer(new_author)).to eq(new_author) }
+      specify do
+        expect { existing_association.writer(nil) }
+          .to change { existing_book.read_attribute(:author_id) }
+          .from(author.id).to(nil)
+      end
+      specify do
+        expect { existing_association.writer(new_author) }
+          .to change { existing_association.reader.try(:attributes) }
+          .from('id' => author.id, 'name' => 'Johny').to('id' => new_author.id, 'name' => 'Morty')
+      end
+      specify do
+        expect { existing_association.writer(new_author) }
+          .to change { existing_book.read_attribute(:author_id) }
+          .from(author.id).to(new_author.id)
+      end
+    end
+  end
+end

data/spec/{lib/granite → granite}/form/model/associations/reflections/embeds_any_spec.rb

@@ -7,7 +7,6 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsAny do
 
     before do
       stub_model(:project) do
-        include Granite::Form::Model::Lifecycle
         attribute :title, String
       end
       stub_model(:user) do
@@ -20,7 +19,7 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsAny do
 
     it { is_expected.to be_a(Granite::Form::Model) }
     it { is_expected.to be_a(Granite::Form::Model::Primary) }
-    it { is_expected.to be_a(Granite::Form::Model::Lifecycle) }
+    it { is_expected.to be_a(Granite::Form::Model::Persistence) }
     it { is_expected.to be_a(Granite::Form::Model::Associations) }
 
     context 'when Granite::Form.base_concern is defined' do

data/spec/{lib/granite → granite}/form/model/associations/reflections/embeds_many_spec.rb

@@ -3,7 +3,8 @@ require 'spec_helper'
 describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
   before do
     stub_model(:project) do
-      include Granite::Form::Model::Lifecycle
+      include Granite::Form::Model::Persistence
+      include Granite::Form::Model::Associations
       attribute :title, String
     end
     stub_model(:user) do
@@ -24,24 +25,28 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
         attribute :name
         embeds_many :projects,
           read: lambda { |reflection, object|
-            value = object.read_attribute(reflection.name)
+            value = object.instance_variable_get("@_value_#{reflection.name}")
             JSON.parse(value) if value.present?
           },
           write: lambda { |reflection, object, value|
-            object.write_attribute(reflection.name, value.to_json)
+            value = value.to_json if value
+            object.instance_variable_set("@_value_#{reflection.name}", value)
           }
       end
     end
 
-    let(:user) { User.instantiate name: 'Rick', projects: [{title: 'Genesis'}].to_json }
+    let(:user) { User.new }
     let(:new_project1) { Project.new(title: 'Project 1') }
     let(:new_project2) { Project.new(title: 'Project 2') }
 
     specify do
-      expect { user.projects.concat([new_project1, new_project2]) }
-        .to change { user.read_attribute(:projects) }
-        .from([{title: 'Genesis'}].to_json)
-        .to([{title: 'Genesis'}, {title: 'Project 1'}, {title: 'Project 2'}].to_json)
+      expect do
+        user.projects = [new_project1, new_project2]
+        user.association(:projects).sync
+      end
+        .to change { user.projects(true) }
+        .from([])
+        .to([have_attributes(title: 'Project 1'), have_attributes(title: 'Project 2')])
     end
   end
 
@@ -54,23 +59,10 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
       specify { expect { user.projects.build(title: 'Project') }.to change { user.projects }.from([]).to([project]) }
     end
 
-    describe '#create' do
-      let(:project) { Project.new title: 'Project' }
-      specify { expect(user.projects.create(title: 'Project')).to eq(project) }
-      specify { expect { user.projects.create(title: 'Project') }.to change { user.projects }.from([]).to([project]) }
-    end
-
-    describe '#create!' do
-      let(:project) { Project.new title: 'Project' }
-      specify { expect(user.projects.create!(title: 'Project')).to eq(project) }
-      specify { expect { user.projects.create!(title: 'Project') }.to change { user.projects }.from([]).to([project]) }
-    end
-
     describe '#reload' do
       let(:project) { Project.new title: 'Project' }
       before do
-        user.update(projects: [project])
-        user.apply_association_changes!
+        user.write_attribute(:projects, [{title: 'Project'}])
       end
       before { user.projects.build }
 
@@ -120,8 +112,8 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
 
       specify { expect(User.reflect_on_association(:projects).klass).to eq(User::Project) }
       specify { expect(User.new.projects).to eq([]) }
-      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.projects).to be_a(Granite::Form::Model::Associations::Collection::Embedded) }
-      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.read_attribute(:projects)).to eq([{'title' => 'Project'}]) }
+      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to be_a(Granite::Form::Model::Associations::Collection::Embedded) }
+      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to match([have_attributes(title: 'Project')]) }
     end
 
     context do
@@ -138,8 +130,8 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
 
       specify { expect(User.reflect_on_association(:projects).klass).to eq(User::Project) }
       specify { expect(User.new.projects).to eq([]) }
-      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.projects).to be_a(Granite::Form::Model::Associations::Collection::Embedded) }
-      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.read_attribute(:projects)).to eq([{'title' => 'Project', 'value' => nil}]) }
+      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to be_a(Granite::Form::Model::Associations::Collection::Embedded) }
+      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to match([have_attributes(title: 'Project', value: nil)]) }
     end
   end
 end

data/spec/{lib/granite → granite}/form/model/associations/reflections/embeds_one_spec.rb

@@ -3,7 +3,8 @@ require 'spec_helper'
 describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
   before do
     stub_model(:author) do
-      include Granite::Form::Model::Lifecycle
+      include Granite::Form::Model::Persistence
+      include Granite::Form::Model::Associations
       attribute :name, String
     end
 
@@ -27,22 +28,26 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
         attribute :title
         embeds_one :author,
           read: lambda { |reflection, object|
-            value = object.read_attribute(reflection.name)
+            value = object.instance_variable_get("@_value_#{reflection.name}")
             JSON.parse(value) if value.present?
           },
           write: lambda { |reflection, object, value|
-            object.write_attribute(reflection.name, value ? value.to_json : nil)
+            value = value.to_json if value
+            object.instance_variable_set("@_value_#{reflection.name}", value)
           }
       end
     end
 
-    let(:book) { Book.instantiate author: {name: 'Duke'}.to_json }
+    let(:book) { Book.new }
     let(:author) { Author.new(name: 'Rick') }
 
     specify do
-      expect { book.author = author }
-        .to change { book.read_attribute(:author) }
-        .from({name: 'Duke'}.to_json).to({name: 'Rick'}.to_json)
+      expect do
+        book.author = author
+        book.association(:author).sync
+      end
+        .to change { book.author(true) }
+        .from(nil).to(have_attributes(name: 'Rick'))
     end
   end
 
@@ -65,18 +70,6 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
     specify { expect { book.build_author(name: 'Author') }.to change { book.author }.from(nil).to(author) }
   end
 
-  describe '#create_author' do
-    let(:author) { Author.new name: 'Author' }
-    specify { expect(book.create_author(name: 'Author')).to eq(author) }
-    specify { expect { book.create_author(name: 'Author') }.to change { book.author }.from(nil).to(author) }
-  end
-
-  describe '#create_author!' do
-    let(:author) { Author.new name: 'Author' }
-    specify { expect(book.create_author!(name: 'Author')).to eq(author) }
-    specify { expect { book.create_author!(name: 'Author') }.to change { book.author }.from(nil).to(author) }
-  end
-
   context 'on the fly' do
     context do
       before do
@@ -92,8 +85,8 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
 
       specify { expect(Book.reflect_on_association(:author).klass).to eq(Book::Author) }
       specify { expect(Book.new.author).to be_nil }
-      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.author).to be_a(Book::Author) }
-      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.read_attribute(:author)).to eq('name' => 'Author') }
+      specify { expect(Book.new.tap { |b| b.build_author(name: 'Author') }.author).to be_a(Book::Author) }
+      specify { expect(Book.new.tap { |b| b.build_author(name: 'Author') }.author).to have_attributes(name: 'Author') }
     end
 
     context do
@@ -110,8 +103,8 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
 
       specify { expect(Book.reflect_on_association(:author).klass).to eq(Book::Author) }
       specify { expect(Book.new.author).to be_nil }
-      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.author).to be_a(Book::Author) }
-      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.read_attribute(:author)).to eq('name' => 'Author', 'age' => nil) }
+      specify { expect(Book.new.tap { |b| b.build_author(name: 'Author') }.author).to be_a(Book::Author) }
+      specify { expect(Book.new.tap { |b| b.build_author(name: 'Author') }.author).to have_attributes(name: 'Author', age: nil) }
     end
   end
 end

data/spec/{lib/granite → granite}/form/model/associations/reflections/references_many_spec.rb

@@ -4,7 +4,7 @@ describe Granite::Form::Model::Associations::Reflections::ReferencesMany do
   before do
     stub_class(:author, ActiveRecord::Base) do
       scope :name_starts_with_a, -> { name_starts_with('a') }
-      scope :name_starts_with, ->(letter) { where("name LIKE '#{letter}%'") }
+      scope :name_starts_with, ->(letter) { where("name ILIKE '#{letter}%'") }
     end
 
     stub_model(:book) do

data/spec/{lib/granite → granite}/form/model/associations/reflections/references_one_spec.rb

@@ -4,7 +4,7 @@ describe Granite::Form::Model::Associations::Reflections::ReferencesOne do
   before do
     stub_class(:author, ActiveRecord::Base) do
       scope :name_starts_with_a, -> { name_starts_with('a') }
-      scope :name_starts_with, ->(letter) { where("name LIKE '#{letter}%'") }
+      scope :name_starts_with, ->(letter) { where("name ILIKE '#{letter}%'") }
     end
 
     stub_model(:book) do
@@ -263,25 +263,4 @@ describe Granite::Form::Model::Associations::Reflections::ReferencesOne do
       specify { expect { book.author_id = nil }.to change { book.author }.from(other).to(nil) }
     end
   end
-
-  describe '#build_author' do
-    specify { expect(book.build_author(name: 'Author')).to be_a(Author) }
-    specify { expect(book.build_author(name: 'Author')).not_to be_persisted }
-    specify { expect { book.build_author(name: 'Author') }.to change { book.author }.from(nil).to(an_instance_of(Author)) }
-    specify { expect { book.build_author(name: 'Author') }.not_to change { book.author_id }.from(nil) }
-  end
-
-  describe '#create_author' do
-    specify { expect(book.create_author(name: 'Author')).to be_a(Author) }
-    specify { expect(book.create_author(name: 'Author')).to be_persisted }
-    specify { expect { book.create_author(name: 'Author') }.to change { book.author }.from(nil).to(an_instance_of(Author)) }
-    specify { expect { book.create_author(name: 'Author') }.to change { book.author_id }.from(nil).to(be_a(Integer)) }
-  end
-
-  describe '#create_author!' do
-    specify { expect(book.create_author!(name: 'Author')).to be_a(Author) }
-    specify { expect(book.create_author!(name: 'Author')).to be_persisted }
-    specify { expect { book.create_author!(name: 'Author') }.to change { book.author }.from(nil).to(an_instance_of(Author)) }
-    specify { expect { book.create_author!(name: 'Author') }.to change { book.author_id }.from(nil).to(be_a(Integer)) }
-  end
 end

data/spec/{lib/granite → granite}/form/model/associations/validations_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 describe Granite::Form::Model::Associations::Validations do
   before do
     stub_model(:project) do
-      include Granite::Form::Model::Lifecycle
       include Granite::Form::Model::Associations
       include Granite::Form::Model::Associations::Validations
 
@@ -17,8 +16,6 @@ describe Granite::Form::Model::Associations::Validations do
     end
 
     stub_model(:profile) do
-      include Granite::Form::Model::Lifecycle
-
       attribute :first_name, String
       attribute :last_name, String
       validates :first_name, presence: true

data/spec/{lib/granite → granite}/form/model/associations_spec.rb

@@ -7,7 +7,7 @@ describe Granite::Form::Model::Associations do
         include Granite::Form::Model::Associations
       end
       stub_model(:project) do
-        include Granite::Form::Model::Lifecycle
+        include Granite::Form::Model::Persistence
       end
       stub_model(:user, Nobody) do
         include Granite::Form::Model::Associations
@@ -65,7 +65,7 @@ describe Granite::Form::Model::Associations do
   context do
     before do
       stub_model(:project) do
-        include Granite::Form::Model::Lifecycle
+        include Granite::Form::Model::Persistence
         include Granite::Form::Model::Associations
 
         attribute :title, String
@@ -80,7 +80,7 @@ describe Granite::Form::Model::Associations do
       end
 
       stub_model(:profile) do
-        include Granite::Form::Model::Lifecycle
+        include Granite::Form::Model::Persistence
 
         attribute :first_name, String
         attribute :last_name, String
@@ -160,27 +160,6 @@ describe Granite::Form::Model::Associations do
       specify { expect(user.association_names).to eq(%i[profile projects]) }
     end
 
-    describe '#apply_association_changes!' do
-      let(:profile) { Profile.new first_name: 'Name' }
-      let(:project) { Project.new title: 'Project' }
-      let(:user) { User.new(profile: profile, projects: [project]) }
-      before { project.build_author(name: 'Author') }
-
-      specify do
-        expect { user.apply_association_changes! }.to change { user.attributes['profile'] }
-          .from(nil).to('first_name' => 'Name', 'last_name' => nil)
-      end
-      specify do
-        expect { user.apply_association_changes! }.to change { user.attributes['projects'] }
-          .from(nil).to([{'title' => 'Project', 'author' => {'name' => 'Author'}}])
-      end
-
-      context do
-        let(:project) { Project.new }
-        specify { expect { user.apply_association_changes! }.to raise_error Granite::Form::AssociationChangesNotApplied }
-      end
-    end
-
     describe '#instantiate' do
       before { User.send(:include, Granite::Form::Model::Persistence) }
       let(:profile) { Profile.new first_name: 'Name' }

data/spec/{lib/granite → granite}/form/model/attributes/attribute_spec.rb

@@ -57,51 +57,6 @@ describe Granite::Form::Model::Attributes::Attribute do
     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) }
 
@@ -144,7 +99,10 @@ describe Granite::Form::Model::Attributes::Attribute do
 
     context 'integration' do
       before do
-        allow(Granite::Form).to receive_messages(config: Granite::Form::Config.send(:new))
+        config = Granite::Form::Config.send(:new)
+        config.types.merge! Granite::Form.config.types
+        allow(Granite::Form).to receive_messages(config: config)
+
         Granite::Form.normalizer(:strip) { |value, _, _| value.strip }
         Granite::Form.normalizer(:trim) do |value, options, _attribute|
           value.first(length || options[:length] || 2)

data/spec/{lib/granite → granite}/form/model/attributes/base_spec.rb

@@ -1,12 +1,14 @@
 require 'spec_helper'
 
 describe Granite::Form::Model::Attributes::Base do
+  let(:model) { Dummy.new }
+
   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)
+    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Base, :field, options.reverse_merge(type: Object))
+    model.attribute(:field)
   end
 
   describe '#read' do
@@ -94,4 +96,11 @@ describe Granite::Form::Model::Attributes::Base do
     specify { expect(attribute(readonly: -> { false })).not_to be_readonly }
     specify { expect(attribute(readonly: -> { true })).to be_readonly }
   end
+
+  describe '#type_definition' do
+    subject { attr.type_definition }
+    let(:attr) { attribute(type: String) }
+
+    it { is_expected.to have_attributes(type: String, reflection: subject.reflection, owner: model) }
+  end
 end

data/spec/{lib/granite → granite}/form/model/attributes/localized_spec.rb

@@ -6,7 +6,7 @@ describe Granite::Form::Model::Attributes::Localized do
   def attribute(*args)
     options = args.extract_options!
     Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Localized, :field, options)
-    described_class.new('field', Dummy.new)
+    Dummy.new.attribute(:field)
   end
 
   describe '#read' do

data/spec/{lib/granite → granite}/form/model/attributes/reflections/attribute_spec.rb

@@ -43,18 +43,6 @@ describe Granite::Form::Model::Attributes::Reflections::Attribute do
     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) }

data/spec/{lib/granite → granite}/form/model/attributes/reflections/base_spec.rb

@@ -36,7 +36,7 @@ describe Granite::Form::Model::Attributes::Reflections::Base do
       stub_class(:owner)
     end
 
-    let(:reflection) { SomeScope::Borogoves.new(:field) }
+    let(:reflection) { SomeScope::Borogoves.new(:field, type: Object) }
     let(:owner) { Owner.new }
 
     specify { expect(reflection.build_attribute(owner, nil)).to be_a(Granite::Form::Model::Attributes::Borogoves) }

data/spec/{lib/granite → granite}/form/model/dirty_spec.rb

@@ -30,7 +30,7 @@ describe Granite::Form::Model::Dirty do
   let(:other_author) { Author.create!(name: 'Other') }
 
   specify { expect(Model.new.changes).to eq({}) }
-  specify { expect(Model.new.tap { |m| m.create_something(value: 'Value') }.changes).to eq({}) }
+  specify { expect(Model.new.tap { |m| m.build_something(value: 'Value') }.changes).to eq({}) }
 
   specify { expect(Model.new(author: author).changes).to eq('author_id' => [nil, author.id]) }
   specify { expect(Model.new(author_id: author.id).changes).to eq('author_id' => [nil, author.id]) }