reform 1.2.6 → 2.0.0.beta1

data/test/setup_test.rb

@@ -0,0 +1,48 @@
+require "test_helper"
+
+class SetupTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
+
+  class AlbumForm < Reform::Form
+    property :name
+    collection :songs do
+      property :title
+
+      property :composer do
+        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") }
+
+  describe "with nested objects" do
+    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"
+      form.songs[0].composer.must_equal nil
+      form.songs[1].title.must_equal "Resist Stance"
+      form.songs[1].composer.name.must_equal "Greg Graffin"
+      form.artist.name.must_equal "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
+    end
+  end
+end

data/test/skip_if_test.rb

@@ -10,10 +10,13 @@ class SkipIfTest < BaseTest
       validates :title, presence: true
     end
 
-    collection :songs, skip_if: lambda { |fragment, *| fragment["title"].nil? },
-      populate_if_empty: BaseTest::Song do
+    collection :songs, skip_if: :skip_song?, populate_if_empty: BaseTest::Song do
       property :title
     end
+
+    def skip_song?(fragment, options)
+      fragment["title"].nil?
+    end
   end
 
 

data/test/skip_setter_and_getter_test.rb

@@ -0,0 +1,54 @@
+require "test_helper"
+
+# Overridden setter won't be called in setup.
+# Overridden getter won't be called in sync.
+class SetupSkipSetterAndGetterTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:title, :artist)
+  Artist = Struct.new(:name)
+
+  class AlbumForm < Reform::Form
+    property :title
+
+    def title
+      super.upcase
+    end
+
+    def title=(v)
+      super v.reverse
+    end
+
+    property :artist do
+      property :name
+
+      def name
+        super.downcase
+      end
+
+      def name=(v)
+        super v.chop
+      end
+    end
+  end
+
+  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"
+
+    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"
+
+    form.sync
+
+    album.title.must_equal "ecnatstsiseR" # setter called, but not getter.
+    album.artist.name.must_equal "Greg Graffi"
+  end
+end

data/test/test_helper.rb

@@ -1,5 +1,7 @@
 require 'reform'
 require 'minitest/autorun'
+require "representable/debug"
+require "pp"
 
 class ReformSpec < MiniTest::Spec
   let (:duran)  { Struct.new(:name).new("Duran Duran") }
@@ -59,4 +61,4 @@ MiniTest::Spec.class_eval do
       @saved
     end
   end
-end
+end

data/test/uniqueness_test.rb

@@ -0,0 +1,41 @@
+require "test_helper"
+
+require "reform/form/validation/unique_validator.rb"
+
+class UniquenessValidatorOnCreateTest < MiniTest::Spec
+  class SongForm < Reform::Form
+    property :title
+    validates :title, unique: true
+  end
+
+  it do
+    Song.delete_all
+
+    form = SongForm.new(Song.new)
+    form.validate("title" => "How Many Tears").must_equal true
+    form.save
+
+    form = SongForm.new(Song.new)
+    form.validate("title" => "How Many Tears").must_equal false
+    form.errors.to_s.must_equal "{:title=>[\"title must be unique.\"]}"
+  end
+end
+
+class UniquenessValidatorOnUpdateTest < MiniTest::Spec
+  class SongForm < Reform::Form
+    property :title
+    validates :title, unique: true
+  end
+
+  it do
+    Song.delete_all
+    @song = Song.create(title: "How Many Tears")
+
+    form = SongForm.new(@song)
+    form.validate("title" => "How Many Tears").must_equal true
+    form.save
+
+    form = SongForm.new(@song)
+    form.validate("title" => "How Many Tears").must_equal true
+  end
+end

data/test/validate_test.rb

@@ -1,362 +1,398 @@
 require 'test_helper'
 
-class ValidateTest < BaseTest
-  describe "populated" do
-    let (:params) {
-      {
-        "title" => "Best Of",
-        "hit"   => {"title" => "Roxanne"},
-        "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"}]
-      }
-    }
-    let (:hit) { Song.new }
-    let (:song2) { Song.new }
-    let (:song1) { Song.new }
-
-    subject { AlbumForm.new(Album.new(nil, hit, [song1, song2])) }
-
-    before { subject.validate(params) }
-
-    it { subject.title.must_equal "Best Of" }
-
-    it { subject.hit.must_be_kind_of Reform::Form }
-    it { subject.hit.title.must_equal "Roxanne" }
-
-    it { subject.songs.must_be_kind_of Array }
-    it { subject.songs.size.must_equal 2 }
-
-    it { subject.songs[0].must_be_kind_of Reform::Form }
-    it { subject.songs[0].title.must_equal "Fallout" }
-
-    it { subject.songs[1].must_be_kind_of Reform::Form }
-    it { subject.songs[1].title.must_equal "Roxanne" }
-
-    # don't touch model.
-    it { hit.title.must_equal nil   }
-    it { song1.title.must_equal nil }
-    it { song2.title.must_equal nil }
-  end
-
-  describe "not populated properly raises error" do
-    it do
-      assert_raises Reform::Form::Validate::DeserializeError do
-        AlbumForm.new(Album.new).validate("hit"   => {"title" => "Roxanne"})
+# tests: -------
+# Contract
+#   validate
+#   errors
+
+# Form
+#   validate
+#   errors
+
+class ContractValidateTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
+
+  class AlbumForm < Reform::Contract
+    property :name
+    validates :name, presence: true
+
+    collection :songs do
+      property :title
+      validates :title, presence: true
+
+      property :composer do
+        validates :name, presence: true
+        property :name
       end
     end
-  end
-
-  # TODO: the following tests go to populate_test.rb
-  describe "manual setup with populator" do
-    let (:form) {
-      Class.new(Reform::Form) do
-        property :hit, :populator => lambda { |fragment, args|
-          puts "******************* #{fragment}"
-
-          hit or self.hit = args.binding[:form].new(Song.new)
-        } do
-          property :title
-        end
-      end
-     }
-
-    let (:params) {
-      {
-        "hit"   => {"title" => "Roxanne"},
-        # "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"}]
-      }
-    }
 
-    subject { form.new(Album.new) }
-
-    before { subject.validate(params) }
-
-    it { subject.hit.title.must_equal "Roxanne" }
+    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) }
 
-  describe ":populator, half-populated collection" do
-    let (:form) {
-      Class.new(Reform::Form) do
-        collection :songs, :populator => lambda { |fragment, index, args|
-          songs[index] or songs[index] = args.binding[:form].new(Song.new)
-        } do
-          property :title
-        end
-      end
-     }
-
-    let (:params) {
-      {
-        "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"}]
-      }
-    }
-    let (:song) { Song.new("Englishman") }
-
-    subject { form.new(Album.new("Hits", nil, [song])) }
-
-    before { subject.validate(params) }
+  let (:form) { AlbumForm.new(album) }
 
-    it { subject.songs[0].model.object_id.must_equal song.object_id } # this song was existing before.
-    it { subject.songs[0].title.must_equal "Fallout" }
-    it { subject.songs[1].title.must_equal "Roxanne" }
+  # 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
 
-  # not sure if we should catch that in Reform or rather do that in disposable. this is https://github.com/apotonick/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
-  #    }
+    form.validate.must_equal false
+    form.errors.messages.inspect.must_equal "{:\"songs.composer.name\"=>[\"can't be blank\"], :name=>[\"can't be blank\"]}"
+  end
+end
 
-  #   let (:params) {
-  #     {
-  #       "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"}]
-  #     }
-  #   }
 
-  #   subject { form.new(Album.new("Hits", [], [])) }
+# 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)
 
-  #   before { subject.validate(params) }
+  class AlbumForm < Reform::Form
+    property :name
+    validates :name, presence: true
 
-  #   it { subject.songs[0].title.must_equal "Fallout" }
-  #   it { subject.songs[1].title.must_equal "Roxanne" }
-  # end
+    collection :songs do
 
+      property :title
+      validates :title, presence: true
 
-  describe ":populate_if_empty, half-populated collection" do
-    let (:form) {
-      Class.new(Reform::Form) do
-        collection :songs, :populate_if_empty => Song do
-          property :title
-        end
+      property :composer do
+        property :name
+        validates :name, presence: true
       end
-     }
-
-    let (:params) {
-      {
-        "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"}]
-      }
-    }
-    let (:song) { Song.new("Englishman") }
-
-    subject { form.new(Album.new("Hits", nil, [song])) }
+    end
 
-    before { subject.validate(params) }
+    property :artist do
+      property :name
+    end
+  end
 
-    it { subject.songs[0].model.object_id.must_equal song.object_id } # this song was existing before.
-    it { subject.songs[0].title.must_equal "Fallout" }
-    it { subject.songs[1].title.must_equal "Roxanne" }
+  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
+end
 
+class ValidateWithDeserializerOptionTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
 
-  describe ":populate_if_empty" do
-    let (:form) {
-      Class.new(Reform::Form) do
-        property :hit, :populate_if_empty => lambda { |fragment, args| Song.new } do
-          property :title
-        end
+  class AlbumForm < Reform::Form
+    property :name
+    validates :name, presence: true
 
-        collection :songs, :populate_if_empty => lambda { |fragment, args| model.songs.build } do
-          property :title
-        end
+    collection :songs,
+      deserializer: {instance: lambda { |fragment, index, options|
+              collection = options.binding.get
+              (item = collection[index]) ? item : collection.insert(index, Song.new) },
+      setter: nil} do
 
-        property :band, :populate_if_empty => lambda { |fragment, args| Band.new } do
-          property :label, :populate_if_empty => lambda { |fragment, args| Label.new } do
-            property :name
-          end
-        end
+      property :title
+      validates :title, presence: true
+
+      property :composer, deserializer: { instance: lambda { |fragment, options| (item = options.binding.get) ? item : Artist.new } } do
+        property :name
+        validates :name, presence: true
       end
-     }
+    end
 
-    let (:params) {
-      {
-        "hit"   => {"title" => "Roxanne"},
-        "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"}],
-        "band"  => {"label" => {"name" => "Epitaph"}}
-      }
-    }
+    property :artist, deserializer: { instance: lambda { |fragment, options| (item = options.binding.get) ? item : Artist.new } } do
+      property :name
+      validates :name, presence: true
+    end
+  end
 
-    let (:song_collection_proxy) { Class.new(Array) { def build; Song.new; end } }
-    let (:album) { Album.new(nil,nil, song_collection_proxy.new, nil) }
-    subject { form.new(album) } # DISCUSS: require at least an array here? this is provided by all ORMs.
+  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
 
-    before { subject.validate(params) }
+  # invalid.
+  it do
+    form.validate(
+      "name"   => "",
+      "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne", "composer" => {"name" => ""}}],
+      "artist" => {"name" => ""},
+    ).must_equal false
 
-    it { subject.hit.title.must_equal "Roxanne" }
-    it { subject.songs[0].title.must_equal "Fallout" }
-    it { subject.songs[1].title.must_equal "Roxanne" }
+    form.errors.messages.inspect.must_equal "{:\"songs.composer.name\"=>[\"can't be blank\"], :\"artist.name\"=>[\"can't be blank\"], :name=>[\"can't be blank\"]}"
+  end
 
-    # population doesn't write to the model.
-    it { album.hit.must_equal nil }
-    it { album.songs.size.must_equal 0 }
+  # 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
 
-    it { subject.band.label.name.must_equal "Epitaph" }
 
+  # allow writeable: false even in the deserializer.
+  class SongForm < Reform::Form
+    property :title, deserializer: {writeable: false}
+  end
 
-    describe "missing parameters" do
-      let (:params) {
-        { }
-      }
+  it do
+    form = SongForm.new(song = Song.new)
+    form.validate("title" => "Ignore me!")
+    form.title.must_equal nil
+    form.title = "Unopened"
+    form.sync # only the deserializer is marked as not-writeable.
+    song.title.must_equal "Unopened"
+  end
+end
 
-      before { subject.validate(params) }
 
-      it { subject.hit.must_equal nil }
-    end
-  end
+#   # not sure if we should catch that in Reform or rather do that in disposable. this is https://github.com/apotonick/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"}]
+#   #     }
+#   #   }
 
-  describe "populate_if_empty: Class" do
-    let (:form) {
-      Class.new(Reform::Form) do
-        property :hit, :populate_if_empty => Song do
-          property :title
-        end
-      end
-     }
+#   #   subject { form.new(Album.new("Hits", [], [])) }
 
-    let (:params) {
-      {
-        "hit"   => {"title" => "Roxanne"},
-      }
-    }
+#   #   before { subject.validate(params) }
 
-    let (:album) { Album.new }
-    subject { form.new(album) }
+#   #   it { subject.songs[0].title.must_equal "Fallout" }
+#   #   it { subject.songs[1].title.must_equal "Roxanne" }
+#   # end
 
-    before { subject.validate(params) }
 
-    it { subject.hit.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
 
-  # test cardinalities.
-  describe "with empty collection and cardinality" do
-    let (:album) { Album.new }
+#       property :hit do
+#         property :title
+#       end
 
-    subject { Class.new(Reform::Form) do
-      include Reform::Form::ActiveModel
-      model :album
+#       validates :songs, :length => {:minimum => 1}
+#       validates :hit, :presence => true
+#     end.new(album) }
 
-      collection :songs do
-        property :title
-      end
 
-      property :hit do
-        property :title
-      end
+#     describe "invalid" do
+#       before { subject.validate({}).must_equal false }
 
-      validates :songs, :length => {:minimum => 1}
-      validates :hit, :presence => true
-    end.new(album) }
+#       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(["can't be blank"])
+#         subject.errors.messages[:songs].first.must_match(/\Ais too short \(minimum is 1 characters?\)\z/)
+#       end
+#     end
 
 
-    describe "invalid" do
-      before { subject.validate({}).must_equal false }
+#     describe "valid" do
+#       let (:album) { Album.new(nil, Song.new, [Song.new("Urban Myth")]) }
 
-      it { subject.errors.messages.must_equal(
-        :songs => ["is too short (minimum is 1 characters)"],
-        :hit   => ["can't be blank"]) }
-    end
+#       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
 
-    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
-      }
+#   describe "with symbols" do
+#     let (:album) { OpenStruct.new(:band => OpenStruct.new(:label => OpenStruct.new(:name => "Epitaph"))) }
+#     subject { ErrorsTest::AlbumForm.new(album) }
+#     let (:params) { {:band => {:label => {:name => "Stiff"}}, :title => "House Of Fun"} }
 
-      it { subject.errors.messages.must_equal({}) }
-    end
-  end
+#     before {
+#       subject.validate(params).must_equal true
+#     }
 
+#     it { subject.band.label.name.must_equal "Stiff" }
+#     it { subject.title.must_equal "House Of Fun" }
+#   end
 
-  describe "with symbols" do
-    let (:album) { OpenStruct.new(:band => OpenStruct.new(:label => OpenStruct.new(:name => "Epitaph"))) }
-    subject { ErrorsTest::AlbumForm.new(album) }
-    let (:params) { {:band => {:label => {:name => "Stiff"}}, :title => "House Of Fun"} }
 
-    before {
-      subject.validate(params).must_equal true
-    }
+#   # providing manual validator method allows accessing form's API.
+#   describe "with ::validate" do
+#     let (:form) {
+#       Class.new(Reform::Form) do
+#         property :title
 
-    it { subject.band.label.name.must_equal "Stiff" }
-    it { subject.title.must_equal "House Of Fun" }
-  end
+#         validate :title?
 
+#         def title?
+#           errors.add :title, "not lowercase" if title == "Fallout"
+#         end
+#       end
+#      }
 
-  # providing manual validator method allows accessing form's API.
-  describe "with ::validate" do
-    let (:form) {
-      Class.new(Reform::Form) do
-        property :title
+#     let (:params) { {"title" => "Fallout"} }
+#     let (:song) { Song.new("Englishman") }
 
-        validate :title?
+#     subject { form.new(song) }
 
-        def title?
-          errors.add :title, "not lowercase" if title == "Fallout"
-        end
-      end
-     }
+#     before { @res = subject.validate(params) }
 
-    let (:params) { {"title" => "Fallout"} }
-    let (:song) { Song.new("Englishman") }
+#     it { @res.must_equal false }
+#     it { subject.errors.messages.must_equal({:title=>["not lowercase"]}) }
+#   end
 
-    subject { form.new(song) }
 
-    before { @res = subject.validate(params) }
+#   # 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
 
-    it { @res.must_equal false }
-    it { subject.errors.messages.must_equal({:title=>["not lowercase"]}) }
-  end
+#         collection :songs, :populate_if_empty => lambda { |*| Song.new } do
+#           property :title
+#         end
 
+#         def band
+#           raise "only call me when rendering the form!"
+#         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
+#         def songs
+#           raise "only call me when rendering the form!"
+#         end
+#       end.new(album)
+#      }
 
-# #validate(params)
-#  title=(params[:title])
-#  song.validate(params[:song], errors)
+#      let (:album) { Album.new }
 
-# #sync (assumes that forms already have updated fields)
-#   model.title=
-#   song.sync
+#      # 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