reform 2.3.2 → 2.6.1

data/test/module_old_api.rb

@@ -1,146 +0,0 @@
-require "test_helper"
-require "reform/form/coercion"
-
-class ModuleInclusionTest < MiniTest::Spec
-  module BandPropertyForm
-    include Reform::Form::Module
-
-    property :artist
-    property :band do
-      property :title
-
-      validation do
-        required(:title).filled
-      end
-
-      def id # gets mixed into Form, too.
-        2
-      end
-    end
-
-    def id # gets mixed into Form, too.
-      1
-    end
-
-    validation do
-      required(:band).filled
-    end
-
-    include Dry::Types.module # allows using Types::* in module.
-    property :cool, type: DRY_TYPES_CONSTANT::Bool # test coercion.
-
-    module InstanceMethods
-      def artist=(new_value)
-        errors.add(:artist, "this needs to be filled") if new_value.nil?
-        super(new_value)
-      end
-    end
-  end
-
-  # TODO: test if works, move stuff into inherit_schema!
-  module AirplaysPropertyForm
-    include Reform::Form::Module
-
-    collection :airplays do
-      property :station
-      validation do
-        required(:station).filled
-      end
-    end
-    validation do
-      required(:airplays).filled
-    end
-  end
-
-  # test:
-  # by including BandPropertyForm into multiple classes we assure that options hashes don't get messed up by AM:V.
-  class HitForm < TestForm
-    include BandPropertyForm
-  end
-
-  class SongForm < TestForm
-    include Coercion
-    property :title
-
-    include BandPropertyForm
-  end
-
-  let(:song) { OpenStruct.new(band: OpenStruct.new(title: "Time Again"), artist: "Ketama") }
-
-  # nested form from module is present and creates accessor.
-  it { SongForm.new(song).band.title.must_equal "Time Again" }
-  it { SongForm.new(song).artist.must_equal "Ketama" }
-
-  # methods from module get included.
-  it { SongForm.new(song).id.must_equal 1 }
-  it { SongForm.new(song).band.id.must_equal 2 }
-
-  # validators get inherited.
-  it do
-    form = SongForm.new(OpenStruct.new)
-    form.validate(artist: nil)
-    form.errors.messages.must_equal(artist: ["this needs to be filled"], band: ["must be filled"])
-  end
-
-  # coercion works
-  it do
-    form = SongForm.new(OpenStruct.new)
-    form.validate({cool: "1"})
-    form.cool.must_equal true
-  end
-
-  # include a module into a module into a class :)
-  module AlbumFormModule
-    include Reform::Form::Module
-    include BandPropertyForm
-
-    property :name
-    validation do
-      required(:name).filled
-    end
-  end
-
-  class AlbumForm < TestForm
-    include AlbumFormModule
-
-    # pp heritage
-    property :band, inherit: true do
-      property :label
-      validation do
-        required(:label).filled
-      end
-    end
-  end
-
-  it do
-    form = AlbumForm.new(OpenStruct.new(band: OpenStruct.new))
-    form.validate("band" => {})
-    form.errors.messages.must_equal("band.title": ["must be filled"], "band.label": ["must be filled"], name: ["must be filled"])
-  end
-
-  describe "module with custom accessors" do
-    module SongModule
-      include Reform::Form::Module
-
-      property :id    # no custom accessor for id.
-      property :title # has custom accessor.
-
-      module InstanceMethods
-        def title
-          super.upcase
-        end
-      end
-    end
-
-    class IncludingSongForm < TestForm
-      include SongModule
-    end
-
-    let(:song) { OpenStruct.new(id: 1, title: "Instant Mash") }
-
-    it do
-      IncludingSongForm.new(song).id.must_equal 1
-      IncludingSongForm.new(song).title.must_equal "INSTANT MASH"
-    end
-  end
-end

data/test/populate_old_api.rb

@@ -1,304 +0,0 @@
-require "test_helper"
-
-class PopulatorTest < MiniTest::Spec
-  Song  = Struct.new(:title, :album, :composer)
-  Album = Struct.new(:name, :songs, :artist)
-  Artist = Struct.new(:name)
-
-  class AlbumForm < TestForm
-    property :name, populator: ->(options) { self.name = options[:fragment].reverse }
-    validation do
-      required(:name).filled
-    end
-
-    collection :songs,
-               populator: ->(fragment:, model:, index:, **) {
-                 (item = model[index]) ? item : model.insert(index, Song.new)
-               } do
-      property :title
-      validation do
-        required(:title).filled
-      end
-
-      property :composer, populator: ->(options) { options[:model] || self.composer = Artist.new } do
-        property :name
-        validation do
-          required(:name).filled
-        end
-      end
-    end
-
-    # property :artist, populator: lambda { |fragment, options| (item = options.binding.get) ? item : Artist.new } do
-    # NOTE: we have to document that model here is the twin!
-    property :artist, populator: ->(options) { options[:model] || self.artist = Artist.new } 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) }
-
-  it "runs populator on scalar" do
-    form.validate(
-      "name" => "override me!"
-    )
-
-    form.name.must_equal "!em edirrevo"
-  end
-
-  # changing existing property :artist.
-  # TODO: check with artist==nil
-  it do
-    old_id = artist.object_id
-
-    form.validate(
-      "artist" => {"name" => "Marcus Miller"}
-    )
-
-    form.artist.model.object_id.must_equal old_id
-  end
-
-  # use populator for default value on scalars?
-
-  # adding to collection via :populator.
-  # valid.
-  it "yyy" do
-    form.validate(
-      "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne"},
-        {"title" => "Rime Of The Ancient Mariner"}, # new song.
-        {"title" => "Re-Education", "composer" => {"name" => "Rise Against"}}], # new song with new composer.
-    ).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].composer.model.must_be_instance_of Artist
-
-    form.songs[1].title.must_equal "Roxanne"
-    form.songs[2].title.must_equal "Rime Of The Ancient Mariner" # new song added.
-    form.songs[3].title.must_equal "Re-Education"
-    form.songs[3].composer.name.must_equal "Rise Against"
-    form.songs.size.must_equal 4
-    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
-end
-
-class PopulateWithMethodTest < Minitest::Spec
-  Album = Struct.new(:title)
-
-  class AlbumForm < TestForm
-    property :title, populator: :title!
-
-    def title!(options)
-      self.title = options[:fragment].reverse
-    end
-  end
-
-  let(:form) { AlbumForm.new(Album.new) }
-
-  it "runs populator method" do
-    form.validate("title" => "override me!")
-
-    form.title.must_equal "!em edirrevo"
-  end
-end
-
-class PopulateWithCallableTest < Minitest::Spec
-  Album = Struct.new(:title)
-
-  class TitlePopulator
-    include Uber::Callable
-
-    def call(form, options)
-      form.title = options[:fragment].reverse
-    end
-  end
-
-  class AlbumForm < TestForm
-    property :title, populator: TitlePopulator.new
-  end
-
-  let(:form) { AlbumForm.new(Album.new) }
-
-  it "runs populator method" do
-    form.validate("title" => "override me!")
-
-    form.title.must_equal "!em edirrevo"
-  end
-end
-
-class PopulateWithProcTest < Minitest::Spec
-  Album = Struct.new(:title)
-
-  TitlePopulator = ->(options) do
-    options[:represented].title = options[:fragment].reverse
-  end
-
-  class AlbumForm < TestForm
-    property :title, populator: TitlePopulator
-  end
-
-  let(:form) { AlbumForm.new(Album.new) }
-
-  it "runs populator method" do
-    form.validate("title" => "override me!")
-
-    form.title.must_equal "!em edirrevo"
-  end
-end
-
-class PopulateIfEmptyTest < MiniTest::Spec
-  Song  = Struct.new(:title, :album, :composer)
-  Album = Struct.new(:name, :songs, :artist)
-  Artist = Struct.new(:name)
-
-  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) }
-
-  class AlbumForm < TestForm
-    property :name
-
-    collection :songs,
-      populate_if_empty: Song do                                                # class name works.
-
-      property :title
-      validation do
-        required(:title).filled
-      end
-
-      property :composer, populate_if_empty: :populate_composer! do # lambda works, too. in form context.
-        property :name
-        validation do
-          required(:name).filled
-        end
-      end
-
-    private
-      def populate_composer!(options)
-        Artist.new
-      end
-    end
-
-    property :artist, populate_if_empty: ->(args) { create_artist(args[:fragment], args[:user_options]) } do # methods work, too.
-      property :name
-    end
-
-    private
-    class Sting < Artist
-      attr_accessor :args
-    end
-    def create_artist(input, user_options)
-      Sting.new.tap { |artist| artist.args = ([input, user_options].to_s) }
-    end
-  end
-
-  let(:form) { AlbumForm.new(album) }
-
-  it do
-    form.songs.size.must_equal 2
-
-    form.validate(
-      "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"},
-        {"title" => "Rime Of The Ancient Mariner"}, # new song.
-        {"title" => "Re-Education", "composer" => {"name" => "Rise Against"}}], # new song with new composer.
-    ).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[3].title.must_equal "Re-Education"
-    form.songs[3].composer.name.must_equal "Rise Against"
-    form.songs.size.must_equal 4
-    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
-
-  # trigger artist populator. lambda calling form instance method.
-  it "xxxx" do
-    form = AlbumForm.new(album = Album.new)
-    form.validate("artist" => {"name" => "From Autumn To Ashes"})
-
-    form.artist.name.must_equal "From Autumn To Ashes"
-    # test lambda was executed in form context.
-    form.artist.model.must_be_instance_of AlbumForm::Sting
-    # test lambda block arguments.
-    form.artist.model.args.to_s.must_equal "[{\"name\"=>\"From Autumn To Ashes\"}, nil]"
-
-    assert_nil album.artist
-  end
-end
-
-# delete songs while deserializing.
-class PopulateIfEmptyWithDeletionTest < MiniTest::Spec
-  Song  = Struct.new(:title, :album, :composer)
-  Album = Struct.new(:name, :songs, :artist)
-
-  let(:song)  { Song.new("Broken") }
-  let(:song2) { Song.new("Resist Stance") }
-  let(:album) { Album.new("The Dissent Of Man", [song, song2]) }
-
-  class AlbumForm < TestForm
-    property :name
-
-    collection :songs,
-      populate_if_empty: Song, skip_if: :delete_song! do
-
-      property :title
-      validation do
-        required(:title).filled
-      end
-    end
-
-    def delete_song!(options)
-      songs.delete(songs[0]) and return true if options[:fragment]["title"] == "Broken, delete me!"
-      false
-    end
-  end
-
-  let(:form) { AlbumForm.new(album) }
-
-  it do
-    form.validate(
-      "songs" => [{"title" => "Broken, delete me!"}, {"title" => "Roxanne"}]
-    ).must_equal true
-
-    form.errors.messages.inspect.must_equal "{}"
-
-    form.songs.size.must_equal 1
-    form.songs[0].title.must_equal "Roxanne"
-  end
-end

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