reform 2.3.0.rc1 → 2.5.0

data/test/setup_test.rb

@@ -20,29 +20,29 @@ class SetupTest < MiniTest::Spec
     end
   end
 
-  let (:song)               { Song.new("Broken") }
-  let (:song_with_composer) { Song.new("Resist Stance", nil, composer) }
-  let (:composer)           { Artist.new("Greg Graffin") }
-  let (:artist)             { Artist.new("Bad Religion") }
+  let(:song)               { Song.new("Broken") }
+  let(:song_with_composer) { Song.new("Resist Stance", nil, composer) }
+  let(:composer)           { Artist.new("Greg Graffin") }
+  let(:artist)             { Artist.new("Bad Religion") }
 
   describe "with nested objects" do
-    let (:album) { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
+    let(:album) { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
 
     it do
       form = AlbumForm.new(album)
 
-      form.name.must_equal "The Dissent Of Man"
-      form.songs[0].title.must_equal "Broken"
+      assert_equal form.name, "The Dissent Of Man"
+      assert_equal form.songs[0].title, "Broken"
       assert_nil form.songs[0].composer
-      form.songs[1].title.must_equal "Resist Stance"
-      form.songs[1].composer.name.must_equal "Greg Graffin"
-      form.artist.name.must_equal "Bad Religion"
+      assert_equal form.songs[1].title, "Resist Stance"
+      assert_equal form.songs[1].composer.name, "Greg Graffin"
+      assert_equal form.artist.name, "Bad Religion"
 
       # make sure all is wrapped in forms.
-      form.songs[0].must_be_kind_of Reform::Form
-      form.songs[1].must_be_kind_of Reform::Form
-      form.songs[1].composer.must_be_kind_of Reform::Form
-      form.artist.must_be_kind_of Reform::Form
+      assert form.songs[0].is_a? Reform::Form
+      assert form.songs[1].is_a? Reform::Form
+      assert form.songs[1].composer.is_a? Reform::Form
+      assert form.artist.is_a? Reform::Form
     end
   end
-end
+end

data/test/skip_if_test.rb

@@ -1,14 +1,16 @@
-require 'test_helper'
+require "test_helper"
 
 class SkipIfTest < BaseTest
+  let(:hit) { Song.new }
+  let(:album) { Album.new(nil, hit, [], nil) }
 
   class AlbumForm < TestForm
     property :title
 
-    property :hit, skip_if: lambda { |options| options[:fragment]["title"]=="" } do
+    property :hit, skip_if: ->(options) { options[:fragment]["title"] == "" } do
       property :title
       validation do
-        required(:title).filled
+        params { required(:title).filled }
       end
     end
 
@@ -21,30 +23,26 @@ class SkipIfTest < BaseTest
     end
   end
 
-
-  let (:hit) { Song.new }
-  let (:album) { Album.new(nil, hit, [], nil) }
-
   # deserializes when present.
   it do
     form = AlbumForm.new(album)
-    form.validate("hit" => {"title" => "Altar Of Sacrifice"}).must_equal true
-    form.hit.title.must_equal "Altar Of Sacrifice"
+    assert form.validate("hit" => {"title" => "Altar Of Sacrifice"})
+    assert_equal form.hit.title, "Altar Of Sacrifice"
   end
 
   # skips deserialization when not present.
   it do
     form = AlbumForm.new(Album.new)
-    form.validate("hit" => {"title" => ""}).must_equal true
+    assert form.validate("hit" => {"title" => ""})
     assert_nil form.hit # hit hasn't been deserialised.
   end
 
   # skips deserialization when not present.
   it do
     form = AlbumForm.new(Album.new(nil, nil, []))
-    form.validate("songs" => [{"title" => "Waste Of Breath"}, {"title" => nil}]).must_equal true
-    form.songs.size.must_equal 1
-    form.songs[0].title.must_equal "Waste Of Breath"
+    assert form.validate("songs" => [{"title" => "Waste Of Breath"}, {"title" => nil}])
+    assert_equal form.songs.size, 1
+    assert_equal form.songs[0].title, "Waste Of Breath"
   end
 end
 
@@ -60,15 +58,28 @@ class SkipIfAllBlankTest < BaseTest
   # create only one object.
   it do
     form = AlbumForm.new(OpenStruct.new(songs: []))
-    form.validate("songs" => [{"title"=>"Apathy"}, {"title"=>"", "length" => ""}]).must_equal true
-    form.songs.size.must_equal 1
-    form.songs[0].title.must_equal "Apathy"
+    assert form.validate("songs" => [{"title" => "Apathy"}, {"title" => "", "length" => ""}])
+    assert_equal form.songs.size, 1
+    assert_equal form.songs[0].title, "Apathy"
   end
 
   it do
     form = AlbumForm.new(OpenStruct.new(songs: []))
-    form.validate("songs" => [{"title"=>"", "length" => ""}, {"title"=>"Apathy"}]).must_equal true
-    form.songs.size.must_equal 1
-    form.songs[0].title.must_equal "Apathy"
+    assert form.validate("songs" => [{"title" => "", "length" => ""}, {"title" => "Apathy"}])
+    assert_equal form.songs.size, 1
+    assert_equal form.songs[0].title, "Apathy"
+  end
+end
+
+class InvalidOptionsCombinationTest < BaseTest
+  it do
+    assert_raises(Reform::Form::InvalidOptionsCombinationError) do
+      class AlbumForm < TestForm
+        collection :songs, skip_if: :all_blank, populator: -> {} do
+          property :title
+          property :length
+        end
+      end
+    end
   end
 end

data/test/skip_setter_and_getter_test.rb

@@ -31,24 +31,23 @@ class SetupSkipSetterAndGetterTest < MiniTest::Spec
     end
   end
 
-  let (:artist) { Artist.new("Bad Religion") }
-
+  let(:artist) { Artist.new("Bad Religion") }
 
   it do
     album = Album.new("Greatest Hits", artist)
     form  = AlbumForm.new(album)
 
-    form.title.must_equal "GREATEST HITS"
-    form.artist.name.must_equal "bad religion"
+    assert_equal form.title, "GREATEST HITS"
+    assert_equal form.artist.name, "bad religion"
 
     form.validate("title" => "Resiststance", "artist" => {"name" => "Greg Graffin"})
 
-    form.title.must_equal "ECNATSTSISER" # first, setter called, then getter.
-    form.artist.name.must_equal "greg graffi"
+    assert_equal form.title, "ECNATSTSISER" # first, setter called, then getter.
+    assert_equal form.artist.name, "greg graffi"
 
     form.sync
 
-    album.title.must_equal "ecnatstsiseR" # setter called, but not getter.
-    album.artist.name.must_equal "Greg Graffi"
+    assert_equal album.title, "ecnatstsiseR" # setter called, but not getter.
+    assert_equal album.artist.name, "Greg Graffi"
   end
-end
+end

data/test/test_helper.rb

@@ -1,11 +1,12 @@
 require "reform"
-require 'minitest/autorun'
+require "minitest/autorun"
 require "representable/debug"
 require "declarative/testing"
 require "pp"
-require 'byebug'
+require "pry-byebug"
 
 require "reform/form/dry"
+
 # setup test classes so we can test without dry being included
 class TestForm < Reform::Form
   feature Reform::Form::Dry
@@ -15,6 +16,10 @@ class TestContract < Reform::Contract
   feature Reform::Form::Dry
 end
 
+module Types
+  include Dry.Types()
+end
+
 class BaseTest < MiniTest::Spec
   class AlbumForm < TestForm
     property :title
@@ -34,11 +39,14 @@ class BaseTest < MiniTest::Spec
   Label  = Struct.new(:name)
   Length = Struct.new(:minutes, :seconds)
 
-
-  let (:hit) { Song.new("Roxanne") }
+  let(:hit) { Song.new("Roxanne") }
 end
 
 MiniTest::Spec.class_eval do
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
+
   module Saveable
     def save
       @saved = true
@@ -49,4 +57,3 @@ MiniTest::Spec.class_eval do
     end
   end
 end
-

data/test/validate_test.rb

@@ -1,25 +1,21 @@
-require 'test_helper'
+require "test_helper"
 
 class ContractValidateTest < MiniTest::Spec
-  Song  = Struct.new(:title, :album, :composer)
-  Album = Struct.new(:name, :songs, :artist)
-  Artist = Struct.new(:name)
-
   class AlbumForm < TestContract
     property :name
     validation do
-      required(:name).filled
+      params { required(:name).filled }
     end
 
     collection :songs do
       property :title
       validation do
-        required(:title).filled
+        params { required(:title).filled }
       end
 
       property :composer do
         validation do
-          required(:name).filled
+          params { required(:name).filled }
         end
         property :name
       end
@@ -30,18 +26,18 @@ class ContractValidateTest < MiniTest::Spec
     end
   end
 
-  let (:song)               { Song.new("Broken") }
-  let (:song_with_composer) { Song.new("Resist Stance", nil, composer) }
-  let (:composer)           { Artist.new("Greg Graffin") }
-  let (:artist)             { Artist.new("Bad Religion") }
-  let (:album)              { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
+  let(:song)               { Song.new("Broken") }
+  let(:song_with_composer) { Song.new("Resist Stance", nil, composer) }
+  let(:composer)           { Artist.new("Greg Graffin") }
+  let(:artist)             { Artist.new("Bad Religion") }
+  let(:album)              { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   # valid
   it do
-    form.validate.must_equal true
-    form.errors.messages.inspect.must_equal "{}"
+    assert form.validate
+    assert_equal form.errors.messages.inspect, "{}"
   end
 
   # invalid
@@ -49,35 +45,29 @@ class ContractValidateTest < MiniTest::Spec
     album.songs[1].composer.name = nil
     album.name = nil
 
-    form.validate.must_equal false
-    form.errors.messages.inspect.must_equal "{:name=>[\"must be filled\"], :\"songs.composer.name\"=>[\"must be filled\"]}"
+    assert_equal form.validate, false
+    assert_equal form.errors.messages.inspect, "{:name=>[\"must be filled\"], :\"songs.composer.name\"=>[\"must be filled\"]}"
   end
 end
 
-
 # no configuration results in "sync" (formerly known as parse_strategy: :sync).
 class ValidateWithoutConfigurationTest < MiniTest::Spec
-  Song  = Struct.new(:title, :album, :composer)
-  Album = Struct.new(:name, :songs, :artist)
-  Artist = Struct.new(:name)
-
   class AlbumForm < TestForm
     property :name
     validation do
-      required(:name).filled
+      params { required(:name).filled }
     end
 
     collection :songs do
-
       property :title
       validation do
-        required(:title).filled
+        params { required(:title).filled }
       end
 
       property :composer do
         property :name
         validation do
-          required(:name).filled
+          params { required(:name).filled }
         end
       end
     end
@@ -87,62 +77,63 @@ class ValidateWithoutConfigurationTest < MiniTest::Spec
     end
   end
 
-  let (:song)               { Song.new("Broken") }
-  let (:song_with_composer) { Song.new("Resist Stance", nil, composer) }
-  let (:composer)           { Artist.new("Greg Graffin") }
-  let (:artist)             { Artist.new("Bad Religion") }
-  let (:album)              { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
+  let(:song)               { Song.new("Broken") }
+  let(:song_with_composer) { Song.new("Resist Stance", nil, composer) }
+  let(:composer)           { Artist.new("Greg Graffin") }
+  let(:artist)             { Artist.new("Bad Religion") }
+  let(:album)              { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   # valid.
   it do
-    object_ids = {song: form.songs[0].object_id, song_with_composer: form.songs[1].object_id,
-      artist: form.artist.object_id, composer: form.songs[1].composer.object_id}
+    object_ids = {
+      song: form.songs[0].object_id, song_with_composer: form.songs[1].object_id,
+      artist: form.artist.object_id, composer: form.songs[1].composer.object_id
+    }
 
-    form.validate(
+    assert form.validate(
       "name"   => "Best Of",
       "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne", "composer" => {"name" => "Sting"}}],
-      "artist" => {"name" => "The Police"},
-    ).must_equal true
+      "artist" => {"name" => "The Police"}
+    )
 
-    form.errors.messages.inspect.must_equal "{}"
+    assert_equal form.errors.messages.inspect, "{}"
 
     # form has updated.
-    form.name.must_equal "Best Of"
-    form.songs[0].title.must_equal "Fallout"
-    form.songs[1].title.must_equal "Roxanne"
-    form.songs[1].composer.name.must_equal "Sting"
-    form.artist.name.must_equal "The Police"
+    assert_equal form.name, "Best Of"
+    assert_equal form.songs[0].title, "Fallout"
+    assert_equal form.songs[1].title, "Roxanne"
+    assert_equal form.songs[1].composer.name, "Sting"
+    assert_equal form.artist.name, "The Police"
 
     # objects are still the same.
-    form.songs[0].object_id.must_equal object_ids[:song]
-    form.songs[1].object_id.must_equal object_ids[:song_with_composer]
-    form.songs[1].composer.object_id.must_equal object_ids[:composer]
-    form.artist.object_id.must_equal object_ids[:artist]
-
+    assert_equal form.songs[0].object_id, object_ids[:song]
+    assert_equal form.songs[1].object_id, object_ids[:song_with_composer]
+    assert_equal form.songs[1].composer.object_id, object_ids[:composer]
+    assert_equal form.artist.object_id, object_ids[:artist]
 
     # model has not changed, yet.
-    album.name.must_equal "The Dissent Of Man"
-    album.songs[0].title.must_equal "Broken"
-    album.songs[1].title.must_equal "Resist Stance"
-    album.songs[1].composer.name.must_equal "Greg Graffin"
-    album.artist.name.must_equal "Bad Religion"
+    assert_equal album.name, "The Dissent Of Man"
+    assert_equal album.songs[0].title, "Broken"
+    assert_equal album.songs[1].title, "Resist Stance"
+    assert_equal album.songs[1].composer.name, "Greg Graffin"
+    assert_equal album.artist.name, "Bad Religion"
   end
 
   # with symbols.
   it do
-    form.validate(
+    assert form.validate(
       name:   "Best Of",
       songs:  [{title: "The X-Creep"}, {title: "Trudging", composer: {name: "SNFU"}}],
-      artist: {name: "The Police"},
-    ).must_equal true
-
-    form.name.must_equal "Best Of"
-    form.songs[0].title.must_equal "The X-Creep"
-    form.songs[1].title.must_equal "Trudging"
-    form.songs[1].composer.name.must_equal "SNFU"
-    form.artist.name.must_equal "The Police"
+      artist: {name: "The Police"}
+    )
+
+    assert_equal form.name, "Best Of"
+    assert_equal form.songs[0].title, "The X-Creep"
+    assert_equal form.songs[1].title, "Trudging"
+    assert_equal form.songs[1].composer.name, "SNFU"
+    assert_equal form.artist.name, "The Police"
   end
 
   # throws exception when no populators.
@@ -156,120 +147,113 @@ class ValidateWithoutConfigurationTest < MiniTest::Spec
 end
 
 class ValidateWithInternalPopulatorOptionTest < MiniTest::Spec
-  Song  = Struct.new(:title, :album, :composer)
-  Album = Struct.new(:name, :songs, :artist)
-  Artist = Struct.new(:name)
-
   class AlbumForm < TestForm
     property :name
     validation do
-      required(:name).filled
+      params { required(:name).filled }
     end
 
     collection :songs,
-      internal_populator: lambda { |input, options|
-              collection = options[:represented].songs
-              (item = collection[options[:index]]) ? item : collection.insert(options[:index], Song.new) } do
-
+               internal_populator: ->(input, options) {
+                 collection = options[:represented].songs
+                 (item = collection[options[:index]]) ? item : collection.insert(options[:index], Song.new)
+               } do
       property :title
       validation do
-        required(:title).filled
+        params { required(:title).filled }
       end
 
-      property :composer, internal_populator: lambda { |input, options| (item = options[:represented].composer) ? item : Artist.new } do
+      property :composer, internal_populator: ->(input, options) { (item = options[:represented].composer) ? item : Artist.new } do
         property :name
         validation do
-          required(:name).filled
+          params { required(:name).filled }
         end
       end
     end
 
-    property :artist, internal_populator: lambda { |input, options| (item = options[:represented].artist) ? item : Artist.new } do
+    property :artist, internal_populator: ->(input, options) { (item = options[:represented].artist) ? item : Artist.new } do
       property :name
       validation do
-        required(:name).filled
+        params { required(:name).filled }
       end
     end
   end
 
-  let (:song)               { Song.new("Broken") }
-  let (:song_with_composer) { Song.new("Resist Stance", nil, composer) }
-  let (:composer)           { Artist.new("Greg Graffin") }
-  let (:artist)             { Artist.new("Bad Religion") }
-  let (:album)              { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
+  let(:song)               { Song.new("Broken") }
+  let(:song_with_composer) { Song.new("Resist Stance", nil, composer) }
+  let(:composer)           { Artist.new("Greg Graffin") }
+  let(:artist)             { Artist.new("Bad Religion") }
+  let(:album)              { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   # valid.
   it("xxx") do
-    form.validate(
+    assert form.validate(
       "name"   => "Best Of",
       "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne", "composer" => {"name" => "Sting"}}],
-      "artist" => {"name" => "The Police"},
-    ).must_equal true
+      "artist" => {"name" => "The Police"}
+    )
 
-    form.errors.messages.inspect.must_equal "{}"
+    assert_equal form.errors.messages.inspect, "{}"
 
     # form has updated.
-    form.name.must_equal "Best Of"
-    form.songs[0].title.must_equal "Fallout"
-    form.songs[1].title.must_equal "Roxanne"
-    form.songs[1].composer.name.must_equal "Sting"
-    form.artist.name.must_equal "The Police"
-
+    assert_equal form.name, "Best Of"
+    assert_equal form.songs[0].title, "Fallout"
+    assert_equal form.songs[1].title, "Roxanne"
+    assert_equal form.songs[1].composer.name, "Sting"
+    assert_equal form.artist.name, "The Police"
 
     # model has not changed, yet.
-    album.name.must_equal "The Dissent Of Man"
-    album.songs[0].title.must_equal "Broken"
-    album.songs[1].title.must_equal "Resist Stance"
-    album.songs[1].composer.name.must_equal "Greg Graffin"
-    album.artist.name.must_equal "Bad Religion"
+    assert_equal album.name, "The Dissent Of Man"
+    assert_equal album.songs[0].title, "Broken"
+    assert_equal album.songs[1].title, "Resist Stance"
+    assert_equal album.songs[1].composer.name, "Greg Graffin"
+    assert_equal album.artist.name, "Bad Religion"
   end
 
   # invalid.
   it do
-    form.validate(
+    assert_equal form.validate(
       "name"   => "",
       "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne", "composer" => {"name" => ""}}],
       "artist" => {"name" => ""},
-    ).must_equal false
+    ), false
 
-    form.errors.messages.inspect.must_equal "{:name=>[\"must be filled\"], :\"songs.composer.name\"=>[\"must be filled\"], :\"artist.name\"=>[\"must be filled\"]}"
+    assert_equal form.errors.messages.inspect, "{:name=>[\"must be filled\"], :\"songs.composer.name\"=>[\"must be filled\"], :\"artist.name\"=>[\"must be filled\"]}"
   end
 
   # adding to collection via :instance.
   # valid.
   it do
-    form.validate(
-      "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne"}, {"title" => "Rime Of The Ancient Mariner"}],
-    ).must_equal true
+    assert form.validate(
+      "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne"}, {"title" => "Rime Of The Ancient Mariner"}]
+    )
 
-    form.errors.messages.inspect.must_equal "{}"
+    assert_equal form.errors.messages.inspect, "{}"
 
     # form has updated.
-    form.name.must_equal "The Dissent Of Man"
-    form.songs[0].title.must_equal "Fallout"
-    form.songs[1].title.must_equal "Roxanne"
-    form.songs[1].composer.name.must_equal "Greg Graffin"
-    form.songs[1].title.must_equal "Roxanne"
-    form.songs[2].title.must_equal "Rime Of The Ancient Mariner" # new song added.
-    form.songs.size.must_equal 3
-    form.artist.name.must_equal "Bad Religion"
-
+    assert_equal form.name, "The Dissent Of Man"
+    assert_equal form.songs[0].title, "Fallout"
+    assert_equal form.songs[1].title, "Roxanne"
+    assert_equal form.songs[1].composer.name, "Greg Graffin"
+    assert_equal form.songs[1].title, "Roxanne"
+    assert_equal form.songs[2].title, "Rime Of The Ancient Mariner" # new song added.
+    assert_equal form.songs.size, 3
+    assert_equal form.artist.name, "Bad Religion"
 
     # model has not changed, yet.
-    album.name.must_equal "The Dissent Of Man"
-    album.songs[0].title.must_equal "Broken"
-    album.songs[1].title.must_equal "Resist Stance"
-    album.songs[1].composer.name.must_equal "Greg Graffin"
-    album.songs.size.must_equal 2
-    album.artist.name.must_equal "Bad Religion"
+    assert_equal album.name, "The Dissent Of Man"
+    assert_equal album.songs[0].title, "Broken"
+    assert_equal album.songs[1].title, "Resist Stance"
+    assert_equal album.songs[1].composer.name, "Greg Graffin"
+    assert_equal album.songs.size, 2
+    assert_equal album.artist.name, "Bad Religion"
   end
 
-
   # allow writeable: false even in the deserializer.
   class SongForm < TestForm
-    property :title, deserializer: { writeable: false }
+    property :title, deserializer: {writeable: false}
   end
 
   it do
@@ -278,13 +262,57 @@ class ValidateWithInternalPopulatorOptionTest < MiniTest::Spec
     assert_nil form.title
     form.title = "Unopened"
     form.sync # only the deserializer is marked as not-writeable.
-    song.title.must_equal "Unopened"
+    assert_equal song.title, "Unopened"
+  end
+end
+
+# memory leak test
+class ValidateUsingDifferentFormObject < MiniTest::Spec
+  class AlbumForm < TestForm
+    property :name
+
+    validation do
+      option :form
+
+      params { required(:name).filled(:str?) }
+
+      rule(:name) do
+        if form.name == 'invalid'
+          key.failure('Invalid name')
+        end
+      end
+    end
+  end
+
+  let(:album) { Album.new }
+
+  let(:form) { AlbumForm.new(album) }
+
+  it 'sets name correctly' do
+    assert form.validate(name: 'valid')
+    form.sync
+    assert_equal form.model.name, 'valid'
+  end
+
+  it 'validates presence of name' do
+    refute form.validate(name: nil)
+    assert_equal form.errors[:name], ["must be filled"]
+  end
+
+  it 'validates type of name' do
+    refute form.validate(name: 1)
+    assert_equal form.errors[:name], ["must be a string"]
+  end
+
+  it 'when name is invalid' do
+    refute form.validate(name: 'invalid')
+    assert_equal form.errors[:name], ["Invalid name"]
   end
 end
 
 #   # not sure if we should catch that in Reform or rather do that in disposable. this is https://github.com/trailblazer/reform/pull/104
 #   # describe ":populator with :empty" do
-#   #   let (:form) {
+#   #   let(:form) {
 #   #     Class.new(Reform::Form) do
 #   #       collection :songs, :empty => true, :populator => lambda { |fragment, index, args|
 #   #         songs[index] = args.binding[:form].new(Song.new)
@@ -294,7 +322,7 @@ end
 #   #     end
 #   #    }
 
-#   #   let (:params) {
+#   #   let(:params) {
 #   #     {
 #   #       "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"}]
 #   #     }
@@ -308,10 +336,9 @@ end
 #   #   it { subject.songs[1].title.must_equal "Roxanne" }
 #   # end
 
-
 #   # test cardinalities.
 #   describe "with empty collection and cardinality" do
-#     let (:album) { Album.new }
+#     let(:album) { Album.new }
 
 #     subject { Class.new(Reform::Form) do
 #       include Reform::Form::ActiveModel
@@ -329,7 +356,6 @@ end
 #       validates :hit, :presence => true
 #     end.new(album) }
 
-
 #     describe "invalid" do
 #       before { subject.validate({}).must_equal false }
 
@@ -342,9 +368,8 @@ end
 #       end
 #     end
 
-
 #     describe "valid" do
-#       let (:album) { Album.new(nil, Song.new, [Song.new("Urban Myth")]) }
+#       let(:album) { Album.new(nil, Song.new, [Song.new("Urban Myth")]) }
 
 #       before {
 #         subject.validate({"songs" => [{"title"=>"Daddy, Brother, Lover, Little Boy"}], "hit" => {"title"=>"The Horse"}}).
@@ -355,13 +380,9 @@ end
 #     end
 #   end
 
-
-
-
-
 #   # providing manual validator method allows accessing form's API.
 #   describe "with ::validate" do
-#     let (:form) {
+#     let(:form) {
 #       Class.new(Reform::Form) do
 #         property :title
 
@@ -373,8 +394,8 @@ end
 #       end
 #      }
 
-#     let (:params) { {"title" => "Fallout"} }
-#     let (:song) { Song.new("Englishman") }
+#     let(:params) { {"title" => "Fallout"} }
+#     let(:song) { Song.new("Englishman") }
 
 #     subject { form.new(song) }
 
@@ -384,10 +405,9 @@ end
 #     it { subject.errors.messages.must_equal({:title=>["not lowercase"]}) }
 #   end
 
-
 #   # overriding the reader for a nested form should only be considered when rendering.
 #   describe "with overridden reader for nested form" do
-#     let (:form) {
+#     let(:form) {
 #       Class.new(Reform::Form) do
 #         property :band, :populate_if_empty => lambda { |*| Band.new } do
 #           property :label
@@ -407,7 +427,7 @@ end
 #       end.new(album)
 #      }
 
-#      let (:album) { Album.new }
+#      let(:album) { Album.new }
 
 #      # don't use #artist when validating!
 #      it do