reform 2.3.3 → 2.5.0

data/test/reform_old_api.rb

@@ -1,202 +0,0 @@
-require "test_helper"
-
-class ReformTest < Minitest::Spec
-  let(:comp) { OpenStruct.new(name: "Duran Duran", title: "Rio") }
-
-  let(:form) { SongForm.new(comp) }
-
-  class SongForm < TestForm
-    property :name
-    property :title
-
-    validation do
-      required(:name).filled
-    end
-  end
-
-  describe "(new) form with empty models" do
-    let(:comp) { OpenStruct.new }
-
-    it "returns empty fields" do
-      assert_nil form.title
-      _(form.name).must_be_nil
-    end
-
-    describe "and submitted values" do
-      it "returns filled-out fields" do
-        form.validate("name" => "Duran Duran")
-
-        assert_nil form.title
-        _(form.name).must_equal "Duran Duran"
-      end
-    end
-  end
-
-  describe "(edit) form with existing models" do
-    it "returns filled-out fields" do
-      _(form.name).must_equal  "Duran Duran"
-      _(form.title).must_equal "Rio"
-    end
-  end
-
-  describe "#validate" do
-    let(:comp) { OpenStruct.new }
-
-    it "ignores unmapped fields in input" do
-      form.validate("name" => "Duran Duran", :genre => "80s")
-      assert_raises NoMethodError do
-        form.genre
-      end
-    end
-
-    it "returns true when valid" do
-      _(form.validate("name" => "Duran Duran")).must_equal true
-    end
-
-    it "exposes input via property accessors" do
-      form.validate("name" => "Duran Duran")
-
-      _(form.name).must_equal "Duran Duran"
-    end
-
-    it "doesn't change model properties" do
-      form.validate("name" => "Duran Duran")
-
-      assert_nil comp.name # don't touch model, yet.
-    end
-
-    # TODO: test errors. test valid.
-    describe "invalid input" do
-      class ValidatingForm < TestForm
-        property :name
-        property :title
-
-        validation do
-          required(:name).filled
-          required(:title).filled
-        end
-      end
-      let(:form) { ValidatingForm.new(comp) }
-
-      it "returns false when invalid" do
-        _(form.validate({})).must_equal false
-      end
-
-      it "populates errors" do
-        form.validate({})
-        _(form.errors.messages).must_equal({name: ["must be filled"], title: ["must be filled"]})
-      end
-    end
-  end
-
-  describe "#save" do
-    let(:comp) { OpenStruct.new }
-    let(:form) { SongForm.new(comp) }
-
-    before { form.validate("name" => "Diesel Boy") }
-
-    it "xxpushes data to models" do
-      form.save
-
-      _(comp.name).must_equal "Diesel Boy"
-      assert_nil comp.title
-    end
-
-    describe "#save with block" do
-      it do
-        hash = {}
-
-        form.save do |map|
-          hash = map
-        end
-
-        _(hash).must_equal({"name" => "Diesel Boy", "title" => nil})
-      end
-    end
-  end
-
-  describe "#model" do
-    it { _(form.model).must_equal comp }
-  end
-
-  describe "inheritance" do
-    class HitForm < SongForm
-      property :position
-      validation do
-        required(:position).filled
-      end
-    end
-
-    let(:form) { HitForm.new(OpenStruct.new()) }
-    it do
-      form.validate({"title" => "The Body"})
-      _(form.title).must_equal "The Body"
-      assert_nil form.position
-      _(form.errors.messages).must_equal({name: ["must be filled"], position: ["must be filled"]})
-    end
-  end
-end
-
-class OverridingAccessorsTest < BaseTest
-  class SongForm < TestForm
-    property :title
-
-    def title=(v) # used in #validate.
-      super v * 2
-    end
-
-    def title # used in #sync.
-      super.downcase
-    end
-  end
-
-  let(:song) { Song.new("Pray") }
-  subject { SongForm.new(song) }
-
-  # override reader for presentation.
-  it { _(subject.title).must_equal "pray" }
-
-  describe "#save" do
-    before { subject.validate("title" => "Hey Little World") }
-
-    # reader always used
-    it { _(subject.title).must_equal "hey little worldhey little world" }
-
-    # the reader is not used when saving/syncing.
-    it do
-      subject.save do |hash|
-        _(hash["title"]).must_equal "Hey Little WorldHey Little World"
-      end
-    end
-
-    # no reader or writer used when saving/syncing.
-    it do
-      song.extend(Saveable)
-      subject.save
-      _(song.title).must_equal "Hey Little WorldHey Little World"
-    end
-  end
-end
-
-class MethodInFormTest < MiniTest::Spec
-  class AlbumForm < TestForm
-    property :title
-
-    def title
-      "The Suffer And The Witness"
-    end
-
-    property :hit do
-      property :title
-
-      def title
-        "Drones"
-      end
-    end
-  end
-
-  # methods can be used instead of created accessors.
-  subject { AlbumForm.new(OpenStruct.new(hit: OpenStruct.new)) }
-  it { _(subject.title).must_equal "The Suffer And The Witness" }
-  it { _(subject.hit.title).must_equal "Drones" }
-end

data/test/save_old_api.rb

@@ -1,101 +0,0 @@
-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
-      required(:name).filled
-    end
-
-    collection :songs do
-      property :title
-      validation do
-        required(:title).filled
-      end
-
-      property :composer do
-        property :name
-        validation do
-          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/skip_if_old_api.rb

@@ -1,92 +0,0 @@
-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/validate_old_api.rb

@@ -1,410 +0,0 @@
-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
-    end
-
-    collection :songs do
-      property :title
-      validation do
-        required(:title).filled
-      end
-
-      property :composer do
-        validation do
-          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
-      required(:name).filled
-    end
-
-    collection :songs do
-      property :title
-      validation do
-        required(:title).filled
-      end
-
-      property :composer do
-        property :name
-        validation do
-          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
-      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
-        required(:title).filled
-      end
-
-      property :composer, internal_populator: ->(input, options) { (item = options[:represented].composer) ? item : Artist.new } do
-        property :name
-        validation do
-          required(:name).filled
-        end
-      end
-    end
-
-    property :artist, internal_populator: ->(input, options) { (item = options[:represented].artist) ? item : Artist.new } do
-      property :name
-      validation do
-        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.valid?).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.valid?).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