reform 2.3.0.rc1 → 2.3.0.rc2

data/test/save_new_api.rb

@@ -0,0 +1,101 @@
+require "test_helper"
+
+class SaveTest < BaseTest
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
+
+  class AlbumForm < TestForm
+    property :name
+    validation do
+      params { required(:name).filled }
+    end
+
+    collection :songs do
+      property :title
+      validation do
+        params { required(:title).filled }
+      end
+
+      property :composer do
+        property :name
+        validation do
+          params { required(:name).filled }
+        end
+      end
+    end
+
+    property :artist, save: false do
+      property :name
+    end
+  end
+
+  module Saveable
+    def save
+      @saved = true
+    end
+
+    def saved?
+      defined?(@saved) && @saved
+    end
+  end
+
+  let(:song)               { Song.new("Broken").extend(Saveable) }
+  # let(:song_with_composer) { Song.new("Resist Stance", nil, composer).extend(Saveable) }
+  let(:composer)           { Artist.new("Greg Graffin").extend(Saveable) }
+  let(:artist)             { Artist.new("Bad Religion").extend(Saveable).extend(Saveable) }
+  let(:album)              { Album.new("The Dissent Of Man", [song], artist).extend(Saveable) }
+
+  let(:form) { AlbumForm.new(album) }
+
+  it do
+    form.validate("songs" => [{"title" => "Fixed"}])
+
+    form.save
+
+    album.saved?.must_equal true
+    album.songs[0].title.must_equal "Fixed"
+    album.songs[0].saved?.must_equal true
+    assert_nil album.artist.saved?
+  end
+
+  describe "#sync with block" do
+    it do
+      form = AlbumForm.new(Album.new("Greatest Hits"))
+
+      form.validate(name: nil) # nil-out the title.
+
+      nested_hash = nil
+      form.sync do |hash|
+        nested_hash = hash
+      end
+
+      nested_hash.must_equal({"name" => nil, "artist" => nil})
+    end
+  end
+end
+
+# class SaveWithDynamicOptionsTest < MiniTest::Spec
+#   Song = Struct.new(:id, :title, :length) do
+#     include Saveable
+#   end
+
+#   class SongForm < TestForm
+#     property :title#, save: false
+#     property :length, virtual: true
+#   end
+
+#   let(:song) { Song.new }
+#   let(:form) { SongForm.new(song) }
+
+#   # we have access to original input value and outside parameters.
+#   it "xxx" do
+#     form.validate("title" => "A Poor Man's Memory", "length" => 10)
+#     length_seconds = 120
+#     form.save(length: lambda { |value, options| form.model.id = "#{value}: #{length_seconds}" })
+
+#     song.title.must_equal "A Poor Man's Memory"
+#     assert_nil song.length
+#     song.id.must_equal "10: 120"
+#   end
+# end

data/test/{save_test.rb → save_old_api.rb}

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class SaveTest < BaseTest
   Song  = Struct.new(:title, :album, :composer)
@@ -40,15 +40,13 @@ class SaveTest < BaseTest
     end
   end
 
+  let(:song)               { Song.new("Broken").extend(Saveable) }
+  # let(:song_with_composer) { Song.new("Resist Stance", nil, composer).extend(Saveable) }
+  let(:composer)           { Artist.new("Greg Graffin").extend(Saveable) }
+  let(:artist)             { Artist.new("Bad Religion").extend(Saveable).extend(Saveable) }
+  let(:album)              { Album.new("The Dissent Of Man", [song], artist).extend(Saveable) }
 
-  let (:song)               { Song.new("Broken").extend(Saveable) }
-  # let (:song_with_composer) { Song.new("Resist Stance", nil, composer).extend(Saveable) }
-  let (:composer)           { Artist.new("Greg Graffin").extend(Saveable) }
-  let (:artist)             { Artist.new("Bad Religion").extend(Saveable).extend(Saveable) }
-  let (:album)              { Album.new("The Dissent Of Man", [song], artist).extend(Saveable) }
-
-  let (:form) { AlbumForm.new(album) }
-
+  let(:form) { AlbumForm.new(album) }
 
   it do
     form.validate("songs" => [{"title" => "Fixed"}])
@@ -72,12 +70,11 @@ class SaveTest < BaseTest
         nested_hash = hash
       end
 
-      nested_hash.must_equal({"name"=>nil, "artist"=>nil})
+      nested_hash.must_equal({"name" => nil, "artist" => nil})
     end
   end
 end
 
-
 # class SaveWithDynamicOptionsTest < MiniTest::Spec
 #   Song = Struct.new(:id, :title, :length) do
 #     include Saveable
@@ -88,8 +85,8 @@ end
 #     property :length, virtual: true
 #   end
 
-#   let (:song) { Song.new }
-#   let (:form) { SongForm.new(song) }
+#   let(:song) { Song.new }
+#   let(:form) { SongForm.new(song) }
 
 #   # we have access to original input value and outside parameters.
 #   it "xxx" do

data/test/setup_test.rb

@@ -20,13 +20,13 @@ 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)
@@ -45,4 +45,4 @@ class SetupTest < MiniTest::Spec
       form.artist.must_be_kind_of Reform::Form
     end
   end
-end
+end

data/test/{skip_if_test.rb → skip_if_new_api.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,10 +23,6 @@ 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)
@@ -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.validate("songs" => [{"title" => "Apathy"}, {"title" => "", "length" => ""}]).must_equal true
     form.songs.size.must_equal 1
     form.songs[0].title.must_equal "Apathy"
   end
 
   it do
     form = AlbumForm.new(OpenStruct.new(songs: []))
-    form.validate("songs" => [{"title"=>"", "length" => ""}, {"title"=>"Apathy"}]).must_equal true
+    form.validate("songs" => [{"title" => "", "length" => ""}, {"title" => "Apathy"}]).must_equal true
     form.songs.size.must_equal 1
     form.songs[0].title.must_equal "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_if_old_api.rb

@@ -0,0 +1,92 @@
+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: ->(options) { options[:fragment]["title"] == "" } do
+      property :title
+      validation do
+        required(:title).filled
+      end
+    end
+
+    collection :songs, skip_if: :skip_song?, populate_if_empty: BaseTest::Song do
+      property :title
+    end
+
+    def skip_song?(options)
+      options[:fragment]["title"].nil?
+    end
+  end
+
+  # 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"
+  end
+
+  # skips deserialization when not present.
+  it do
+    form = AlbumForm.new(Album.new)
+    form.validate("hit" => {"title" => ""}).must_equal true
+    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"
+  end
+end
+
+class SkipIfAllBlankTest < BaseTest
+  # skip_if: :all_blank"
+  class AlbumForm < TestForm
+    collection :songs, skip_if: :all_blank, populate_if_empty: BaseTest::Song do
+      property :title
+      property :length
+    end
+  end
+
+  # 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"
+  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"
+  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"
+  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,8 +31,7 @@ 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)
@@ -51,4 +50,4 @@ class SetupSkipSetterAndGetterTest < MiniTest::Spec
     album.title.must_equal "ecnatstsiseR" # setter called, but not getter.
     album.artist.name.must_equal "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 "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,15 @@ class TestContract < Reform::Contract
   feature Reform::Form::Dry
 end
 
+module Types
+  DRY_MODULE = Gem::Version.new(Dry::Types::VERSION) < Gem::Version.new("0.15.0") ? Dry::Types.module : Dry.Types()
+  include DRY_MODULE
+end
+
+DRY_TYPES_VERSION = Gem::Version.new(Dry::Types::VERSION)
+DRY_TYPES_CONSTANT = DRY_TYPES_VERSION < Gem::Version.new("0.13.0") ? Types::Form : Types::Params
+DRY_TYPES_INT_CONSTANT = DRY_TYPES_VERSION < Gem::Version.new("0.13.0") ? Types::Form::Int : Types::Params::Integer
+
 class BaseTest < MiniTest::Spec
   class AlbumForm < TestForm
     property :title
@@ -34,8 +44,7 @@ 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
@@ -49,4 +58,3 @@ MiniTest::Spec.class_eval do
     end
   end
 end
-

data/test/validate_new_api.rb

@@ -0,0 +1,408 @@
+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
+      params { required(:name).filled }
+    end
+
+    collection :songs do
+      property :title
+      validation do
+        params { required(:title).filled }
+      end
+
+      property :composer do
+        validation do
+          params { required(:name).filled }
+        end
+        property :name
+      end
+    end
+
+    property :artist do
+      property :name
+    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(:form) { AlbumForm.new(album) }
+
+  # valid
+  it do
+    form.validate.must_equal true
+    form.errors.messages.inspect.must_equal "{}"
+  end
+
+  # invalid
+  it do
+    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\"]}"
+  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
+      params { required(:name).filled }
+    end
+
+    collection :songs do
+      property :title
+      validation do
+        params { required(:title).filled }
+      end
+
+      property :composer do
+        property :name
+        validation do
+          params { required(:name).filled }
+        end
+      end
+    end
+
+    property :artist do
+      property :name
+    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(: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
+    }
+
+    form.validate(
+      "name"   => "Best Of",
+      "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne", "composer" => {"name" => "Sting"}}],
+      "artist" => {"name" => "The Police"}
+    ).must_equal true
+
+    form.errors.messages.inspect.must_equal "{}"
+
+    # 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"
+
+    # 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]
+
+    # 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"
+  end
+
+  # with symbols.
+  it do
+    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"
+  end
+
+  # throws exception when no populators.
+  it do
+    album = Album.new("The Dissent Of Man", [])
+
+    assert_raises RuntimeError do
+      AlbumForm.new(album).validate(songs: {title: "Resist-Stance"})
+    end
+  end
+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
+      params { required(:name).filled }
+    end
+
+    collection :songs,
+               internal_populator: ->(input, options) {
+                 collection = options[:represented].songs
+                 (item = collection[options[:index]]) ? item : collection.insert(options[:index], Song.new)
+               } do
+      property :title
+      validation do
+        params { required(:title).filled }
+      end
+
+      property :composer, internal_populator: ->(input, options) { (item = options[:represented].composer) ? item : Artist.new } do
+        property :name
+        validation do
+          params { required(:name).filled }
+        end
+      end
+    end
+
+    property :artist, internal_populator: ->(input, options) { (item = options[:represented].artist) ? item : Artist.new } do
+      property :name
+      validation do
+        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(:form) { AlbumForm.new(album) }
+
+  # valid.
+  it("xxx") do
+    form.validate(
+      "name"   => "Best Of",
+      "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne", "composer" => {"name" => "Sting"}}],
+      "artist" => {"name" => "The Police"},
+    ).must_equal true
+
+    form.errors.messages.inspect.must_equal "{}"
+
+    # 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"
+
+    # 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"
+  end
+
+  # invalid.
+  it do
+    form.validate(
+      "name"   => "",
+      "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne", "composer" => {"name" => ""}}],
+      "artist" => {"name" => ""},
+    ).must_equal false
+
+    form.errors.messages.inspect.must_equal "{: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
+
+    form.errors.messages.inspect.must_equal "{}"
+
+    # 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"
+
+    # 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"
+  end
+
+  # allow writeable: false even in the deserializer.
+  class SongForm < TestForm
+    property :title, deserializer: {writeable: false}
+  end
+
+  it do
+    form = SongForm.new(song = Song.new)
+    form.validate("title" => "Ignore me!")
+    assert_nil form.title
+    form.title = "Unopened"
+    form.sync # only the deserializer is marked as not-writeable.
+    song.title.must_equal "Unopened"
+  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) {
+#   #     Class.new(Reform::Form) do
+#   #       collection :songs, :empty => true, :populator => lambda { |fragment, index, args|
+#   #         songs[index] = args.binding[:form].new(Song.new)
+#   #       } do
+#   #         property :title
+#   #       end
+#   #     end
+#   #    }
+
+#   #   let(:params) {
+#   #     {
+#   #       "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"}]
+#   #     }
+#   #   }
+
+#   #   subject { form.new(Album.new("Hits", [], [])) }
+
+#   #   before { subject.validate(params) }
+
+#   #   it { subject.songs[0].title.must_equal "Fallout" }
+#   #   it { subject.songs[1].title.must_equal "Roxanne" }
+#   # end
+
+#   # test cardinalities.
+#   describe "with empty collection and cardinality" do
+#     let(:album) { Album.new }
+
+#     subject { Class.new(Reform::Form) do
+#       include Reform::Form::ActiveModel
+#       model :album
+
+#       collection :songs do
+#         property :title
+#       end
+
+#       property :hit do
+#         property :title
+#       end
+
+#       validates :songs, :length => {:minimum => 1}
+#       validates :hit, :presence => true
+#     end.new(album) }
+
+#     describe "invalid" do
+#       before { subject.validate({}).must_equal false }
+
+#       it do
+#         # ensure that only hit and songs keys are present
+#         subject.errors.messages.keys.sort.must_equal([:hit, :songs])
+#         # validate content of hit and songs keys
+#         subject.errors.messages[:hit].must_equal(["must be filled"])
+#         subject.errors.messages[:songs].first.must_match(/\Ais too short \(minimum is 1 characters?\)\z/)
+#       end
+#     end
+
+#     describe "valid" do
+#       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"}}).
+#           must_equal true
+#       }
+
+#       it { subject.errors.messages.must_equal({}) }
+#     end
+#   end
+
+#   # providing manual validator method allows accessing form's API.
+#   describe "with ::validate" do
+#     let(:form) {
+#       Class.new(Reform::Form) do
+#         property :title
+
+#         validate :title?
+
+#         def title?
+#           errors.add :title, "not lowercase" if title == "Fallout"
+#         end
+#       end
+#      }
+
+#     let(:params) { {"title" => "Fallout"} }
+#     let(:song) { Song.new("Englishman") }
+
+#     subject { form.new(song) }
+
+#     before { @res = subject.validate(params) }
+
+#     it { @res.must_equal false }
+#     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) {
+#       Class.new(Reform::Form) do
+#         property :band, :populate_if_empty => lambda { |*| Band.new } do
+#           property :label
+#         end
+
+#         collection :songs, :populate_if_empty => lambda { |*| Song.new } do
+#           property :title
+#         end
+
+#         def band
+#           raise "only call me when rendering the form!"
+#         end
+
+#         def songs
+#           raise "only call me when rendering the form!"
+#         end
+#       end.new(album)
+#      }
+
+#      let(:album) { Album.new }
+
+#      # don't use #artist when validating!
+#      it do
+#        form.validate("band" => {"label" => "Hellcat"}, "songs" => [{"title" => "Stand Your Ground"}, {"title" => "Otherside"}])
+#        form.sync
+#        album.band.label.must_equal "Hellcat"
+#        album.songs.first.title.must_equal "Stand Your Ground"
+#      end
+#   end
+# end