reform 2.2.4 → 2.6.2

data/test/parse_pipeline_test.rb

@@ -3,13 +3,13 @@ require "test_helper"
 class ParsePipelineTest < MiniTest::Spec
   Album = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
-    property :name, deserializer: { parse_pipeline: ->(input, options) { Representable::Pipeline[->(input, options) { options[:represented].name = input.inspect }] } }
+  class AlbumForm < TestForm
+    property :name, deserializer: {parse_pipeline: ->(input, options) { Representable::Pipeline[->(ipt, opts) { opts[:represented].name = ipt.inspect }] }}
   end
 
   it "allows passing :parse_pipeline directly" do
     form = AlbumForm.new(Album.new)
     form.validate("name" => "Greatest Hits")
-    form.name.must_equal "{\"name\"=>\"Greatest Hits\"}"
+    assert_equal form.name, "{\"name\"=>\"Greatest Hits\"}"
   end
-end
+end

data/test/populate_test.rb

@@ -5,27 +5,25 @@ class PopulatorTest < MiniTest::Spec
   Album = Struct.new(:name, :songs, :artist)
   Artist = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :name, populator: ->(options) { self.name = options[:fragment].reverse }
     validation do
-      key(:name).required
+      params { required(:name).filled }
     end
 
     collection :songs,
-      populator: ->(options) {
-        fragment, collection, index = options[:fragment], options[:model], options[:index]
-
-        (item = collection[index]) ? item : collection.insert(index, Song.new) } do
-
+               populator: ->(fragment:, model:, index:, **) {
+                 (item = model[index]) ? item : model.insert(index, Song.new)
+               } do
       property :title
       validation do
-        key(:title).required
+        params { required(:title).filled }
       end
 
-      property :composer, populator: ->(options) { options[:model] || self.composer= Artist.new } do
+      property :composer, populator: ->(options) { options[:model] || self.composer = Artist.new } do
         property :name
         validation do
-          key(:name).required
+          params { required(:name).filled }
         end
       end
     end
@@ -37,20 +35,20 @@ class PopulatorTest < MiniTest::Spec
     end
   end
 
-  let (:song)               { Song.new("Broken") }
-  let (:song_with_composer) { Song.new("Resist Stance", nil, composer) }
-  let (:composer)           { Artist.new("Greg Graffin") }
-  let (:artist)             { Artist.new("Bad Religion") }
-  let (:album)              { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
+  let(:song)               { Song.new("Broken") }
+  let(:song_with_composer) { Song.new("Resist Stance", nil, composer) }
+  let(:composer)           { Artist.new("Greg Graffin") }
+  let(:artist)             { Artist.new("Bad Religion") }
+  let(:album)              { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   it "runs populator on scalar" do
     form.validate(
       "name" => "override me!"
     )
 
-    form.name.must_equal "!em edirrevo"
+    assert_equal form.name, "!em edirrevo"
   end
 
   # changing existing property :artist.
@@ -62,7 +60,7 @@ class PopulatorTest < MiniTest::Spec
       "artist" => {"name" => "Marcus Miller"}
     )
 
-    form.artist.model.object_id.must_equal old_id
+    assert_equal form.artist.model.object_id, old_id
   end
 
   # use populator for default value on scalars?
@@ -70,44 +68,43 @@ class PopulatorTest < MiniTest::Spec
   # adding to collection via :populator.
   # valid.
   it "yyy" do
-    form.validate(
+    assert 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 "{}"
+    assert_equal form.errors.messages.inspect, "{}"
 
     # form has updated.
-    form.name.must_equal "The Dissent Of Man"
-    form.songs[0].title.must_equal "Fallout"
-    form.songs[1].title.must_equal "Roxanne"
-    form.songs[1].composer.name.must_equal "Greg Graffin"
-
-    form.songs[1].composer.model.must_be_instance_of Artist
+    assert_equal form.name, "The Dissent Of Man"
+    assert_equal form.songs[0].title, "Fallout"
+    assert_equal form.songs[1].title, "Roxanne"
+    assert_equal form.songs[1].composer.name, "Greg Graffin"
 
-    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"
+    form.songs[1].composer.model.is_a? Artist
 
+    assert_equal form.songs[1].title, "Roxanne"
+    assert_equal form.songs[2].title, "Rime Of The Ancient Mariner" # new song added.
+    assert_equal form.songs[3].title, "Re-Education"
+    assert_equal form.songs[3].composer.name, "Rise Against"
+    assert_equal form.songs.size, 4
+    assert_equal form.artist.name, "Bad Religion"
 
     # model has not changed, yet.
-    album.name.must_equal "The Dissent Of Man"
-    album.songs[0].title.must_equal "Broken"
-    album.songs[1].title.must_equal "Resist Stance"
-    album.songs[1].composer.name.must_equal "Greg Graffin"
-    album.songs.size.must_equal 2
-    album.artist.name.must_equal "Bad Religion"
+    assert_equal album.name, "The Dissent Of Man"
+    assert_equal album.songs[0].title, "Broken"
+    assert_equal album.songs[1].title, "Resist Stance"
+    assert_equal album.songs[1].composer.name, "Greg Graffin"
+    assert_equal album.songs.size, 2
+    assert_equal album.artist.name, "Bad Religion"
   end
 end
 
 class PopulateWithMethodTest < Minitest::Spec
   Album = Struct.new(:title)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :title, populator: :title!
 
     def title!(options)
@@ -115,14 +112,80 @@ class PopulateWithMethodTest < Minitest::Spec
     end
   end
 
-  let (:form) { AlbumForm.new(Album.new) }
+  let(:form) { AlbumForm.new(Album.new) }
 
   it "runs populator method" do
-    form.validate(
-      "title" => "override me!"
-    )
+    form.validate("title" => "override me!")
+
+    assert_equal form.title, "!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 TitlePopulatorWithOldSignature
+    include Uber::Callable
+
+    def call(form, options)
+      form.title = options[:fragment].reverse
+    end
+  end
+
+  class AlbumForm < TestForm
+    property :title, populator: TitlePopulator.new
+  end
+
+  class AlbumFormWithOldPopulator < TestForm
+    property :title, populator: TitlePopulatorWithOldSignature.new
+  end
+
+  let(:form) { AlbumForm.new(Album.new) }
+
+  it "runs populator method" do
+    form.validate("title" => "override me!")
+
+    assert_equal form.title, "!em edirrevo"
+  end
+
+  it "gives warning when `form` is accepted as a positional argument" do
+    _, warnings = capture_io do
+      form = AlbumFormWithOldPopulator.new(Album.new)
+      form.validate("title" => "override me!")
+
+      assert_equal form.title, "!em edirrevo"
+    end
+
+    assert_equal warnings, %{[Reform] Accepting `form` as a positional argument in `:populator` will be deprecated. Please use `def call(form:, **options)` signature instead.
+}
+  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) }
 
-    form.title.must_equal "!em edirrevo"
+  it "runs populator method" do
+    form.validate("title" => "override me!")
+
+    assert_equal form.title, "!em edirrevo"
   end
 end
 
@@ -131,15 +194,13 @@ class PopulateIfEmptyTest < MiniTest::Spec
   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) }
-
+  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 < Reform::Form
+  class AlbumForm < TestForm
     property :name
 
     collection :songs,
@@ -147,68 +208,67 @@ class PopulateIfEmptyTest < MiniTest::Spec
 
       property :title
       validation do
-        key(:title).required
+        params { required(:title).filled }
       end
 
       property :composer, populate_if_empty: :populate_composer! do # lambda works, too. in form context.
         property :name
         validation do
-          key(:name).required
+          params { required(:name).filled }
         end
       end
 
     private
-      def populate_composer!(fragment, options)
+      def populate_composer!(options)
         Artist.new
       end
     end
 
-    property :artist, populate_if_empty: lambda { |args| create_artist(args[:fragment], args[:user_options]) } do # methods work, too.
+    property :artist, populate_if_empty: ->(args) { create_artist(args[:fragment], args[:user_options]) } do # methods work, too.
       property :name
     end
 
-  private
+    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) }
+      Sting.new.tap { |artist| artist.args = ([input, user_options].to_s) }
     end
   end
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   it do
-    form.songs.size.must_equal 2
+    assert_equal form.songs.size, 2
 
-    form.validate(
-      "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne"},
+    assert 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 "{}"
+    assert_equal form.errors.messages.inspect, "{}"
 
     # form has updated.
-    form.name.must_equal "The Dissent Of Man"
-    form.songs[0].title.must_equal "Fallout"
-    form.songs[1].title.must_equal "Roxanne"
-    form.songs[1].composer.name.must_equal "Greg Graffin"
-    form.songs[1].title.must_equal "Roxanne"
-    form.songs[2].title.must_equal "Rime Of The Ancient Mariner" # new song added.
-    form.songs[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"
-
+    assert_equal form.name, "The Dissent Of Man"
+    assert_equal form.songs[0].title, "Fallout"
+    assert_equal form.songs[1].title, "Roxanne"
+    assert_equal form.songs[1].composer.name, "Greg Graffin"
+    assert_equal form.songs[1].title, "Roxanne"
+    assert_equal form.songs[2].title, "Rime Of The Ancient Mariner" # new song added.
+    assert_equal form.songs[3].title, "Re-Education"
+    assert_equal form.songs[3].composer.name, "Rise Against"
+    assert_equal form.songs.size, 4
+    assert_equal form.artist.name, "Bad Religion"
 
     # model has not changed, yet.
-    album.name.must_equal "The Dissent Of Man"
-    album.songs[0].title.must_equal "Broken"
-    album.songs[1].title.must_equal "Resist Stance"
-    album.songs[1].composer.name.must_equal "Greg Graffin"
-    album.songs.size.must_equal 2
-    album.artist.name.must_equal "Bad Religion"
+    assert_equal album.name, "The Dissent Of Man"
+    assert_equal album.songs[0].title, "Broken"
+    assert_equal album.songs[1].title, "Resist Stance"
+    assert_equal album.songs[1].composer.name, "Greg Graffin"
+    assert_equal album.songs.size, 2
+    assert_equal album.artist.name, "Bad Religion"
   end
 
   # trigger artist populator. lambda calling form instance method.
@@ -216,28 +276,26 @@ class PopulateIfEmptyTest < MiniTest::Spec
     form = AlbumForm.new(album = Album.new)
     form.validate("artist" => {"name" => "From Autumn To Ashes"})
 
-    form.artist.name.must_equal "From Autumn To Ashes"
+    assert_equal form.artist.name, "From Autumn To Ashes"
     # test lambda was executed in form context.
-    form.artist.model.must_be_instance_of AlbumForm::Sting
+    assert form.artist.model.is_a? AlbumForm::Sting
     # test lambda block arguments.
-    form.artist.model.args.to_s.must_equal "[{\"name\"=>\"From Autumn To Ashes\"}, nil]"
+    assert_equal form.artist.model.args.to_s, "[{\"name\"=>\"From Autumn To Ashes\"}, nil]"
 
-    album.artist.must_equal 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]) }
-
+  let(:song)  { Song.new("Broken") }
+  let(:song2) { Song.new("Resist Stance") }
+  let(:album) { Album.new("The Dissent Of Man", [song, song2]) }
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :name
 
     collection :songs,
@@ -245,7 +303,7 @@ class PopulateIfEmptyWithDeletionTest < MiniTest::Spec
 
       property :title
       validation do
-        key(:title).required
+        params { required(:title).filled }
       end
     end
 
@@ -255,16 +313,75 @@ class PopulateIfEmptyWithDeletionTest < MiniTest::Spec
     end
   end
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   it do
-    form.validate(
-      "songs"  => [{"title" => "Broken, delete me!"}, {"title" => "Roxanne"}]
-    ).must_equal true
+    assert form.validate(
+      "songs" => [{"title" => "Broken, delete me!"}, {"title" => "Roxanne"}]
+    )
+
+    assert_equal form.errors.messages.inspect, "{}"
+
+    assert_equal form.songs.size, 1
+    assert_equal form.songs[0].title, "Roxanne"
+  end
+end
+
+class PopulateWithFormKeyTest < 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 SongForm < TestForm
+    property :title
+
+    validation do
+      params { required(:title).filled }
+    end
+  end
+
+  class AlbumForm < TestForm
+    property :name
 
-    form.errors.messages.inspect.must_equal "{}"
+    collection :songs, form: SongForm, populator: :populator!, model_identifier: :title
 
-    form.songs.size.must_equal 1
-    form.songs[0].title.must_equal "Roxanne"
+    def populator!(fragment:, **)
+      item = songs.find { |song| song.title == fragment['title'] }
+      if item && fragment['delete'] == '1'
+        songs.delete(item)
+        return skip!
+      end
+      item || songs.append(Song.new)
+    end
+  end
+
+  let(:form) { AlbumForm.new(album) }
+
+  it do
+    assert_equal 2, form.songs.size
+
+    assert form.validate(
+      'songs' => [
+        { 'title' => 'Broken' },
+        { 'title' => 'Resist Stance' },
+        { 'title' => 'Rime Of The Ancient Mariner' }
+      ]
+    )
+
+    assert_equal 3, form.songs.size
+
+    assert form.validate(
+      'songs' => [
+        { 'title' => 'Broken', 'delete' => '1' },
+        { 'title' => 'Resist Stance' },
+        { 'title' => 'Rime Of The Ancient Mariner' }
+      ]
+    )
+    assert_equal 2, form.songs.size
+    assert_equal 'Resist Stance', form.songs.first.title
+    assert_equal 'Rime Of The Ancient Mariner', form.songs.last.title
   end
 end

data/test/populator_skip_test.rb

@@ -4,14 +4,14 @@ class PopulatorSkipTest < MiniTest::Spec
   Album = Struct.new(:songs)
   Song  = Struct.new(:title)
 
+  class AlbumForm < TestForm
+    collection :songs, populator: :my_populator do
+      property :title
+    end
 
-  class AlbumForm < Reform::Form
-    collection :songs,
-      populator: ->(options) {
-        return skip! if options[:fragment][:title] == "Good"
-        songs[options[:index]]
-      } do
-        property :title
+    def my_populator(options)
+      return skip! if options[:fragment][:title] == "Good"
+      songs[options[:index]]
     end
   end
 
@@ -21,8 +21,8 @@ class PopulatorSkipTest < MiniTest::Spec
 
     form.validate(hash)
 
-    form.songs.size.must_equal 2
-    form.songs[0].title.must_equal nil
-    form.songs[1].title.must_equal "Bad"
+    assert_equal form.songs.size, 2
+    assert_nil form.songs[0].title
+    assert_equal form.songs[1].title, "Bad"
   end
-end
+end

data/test/prepopulator_test.rb

@@ -1,17 +1,17 @@
-require 'test_helper'
+require "test_helper"
 
 class PrepopulatorTest < MiniTest::Spec
   Song = Struct.new(:title, :band, :length)
   Band = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
-    property :title, prepopulator: ->(*){ self.title = "Another Day At Work" }                  # normal assignment.
+  class AlbumForm < TestForm
+    property :title, prepopulator: ->(*) { self.title = "Another Day At Work" }                  # normal assignment.
     property :length
 
     property :hit, prepopulator: ->(options) { self.hit = Song.new(options[:title]) } do # use user options.
       property :title
 
-      property :band, prepopulator: ->(options){ self.band = my_band(options[:title]) } do                             # invoke your own code.
+      property :band, prepopulator: ->(options) { self.band = my_band(options[:title]) } do                             # invoke your own code.
         property :name
       end
 
@@ -24,7 +24,7 @@ class PrepopulatorTest < MiniTest::Spec
         property :title
     end
 
-  private
+    private
     def prepopulate_songs!(options)
       if songs == nil
         self.songs = [Song.new, Song.new]
@@ -37,25 +37,25 @@ class PrepopulatorTest < MiniTest::Spec
   it do
     form = AlbumForm.new(OpenStruct.new(length: 1)).prepopulate!(title: "Potemkin City Limits")
 
-    form.length.must_equal 1
-    form.title.must_equal "Another Day At Work"
-    form.hit.model.must_equal Song.new("Potemkin City Limits")
-    form.songs.size.must_equal 2
-    form.songs[0].model.must_equal Song.new
-    form.songs[1].model.must_equal Song.new
-    form.songs[1].model.must_equal Song.new
+    assert_equal form.length, 1
+    assert_equal form.title, "Another Day At Work"
+    assert_equal form.hit.model, Song.new("Potemkin City Limits")
+    assert_equal form.songs.size, 2
+    assert_equal form.songs[0].model, Song.new
+    assert_equal form.songs[1].model, Song.new
+    assert_equal form.songs[1].model, Song.new
     # prepopulate works more than 1 level, recursive.
     # it also passes options properly down there.
-    form.hit.band.model.must_equal Band.new("Potemkin City Limits")
+    assert_equal form.hit.band.model, Band.new("Potemkin City Limits")
   end
 
   # add to existing collection.
   it do
-    form = AlbumForm.new(OpenStruct.new(songs: [Song.new])).prepopulate!
+    form = AlbumForm.new(OpenStruct.new(songs: [Song.new])).prepopulate!(title: "Potemkin City Limits")
 
-    form.songs.size.must_equal 2
-    form.songs[0].model.must_equal Song.new
-    form.songs[1].model.must_equal Song.new
+    assert_equal form.songs.size, 2
+    assert_equal form.songs[0].model, Song.new
+    assert_equal form.songs[1].model, Song.new
   end
 end
 
@@ -63,7 +63,7 @@ end
 class PrepopulateWithoutConfiguration < MiniTest::Spec
   Song = Struct.new(:title)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     collection :songs do
       property :title
     end
@@ -75,15 +75,14 @@ class PrepopulateWithoutConfiguration < MiniTest::Spec
 
   subject { AlbumForm.new(OpenStruct.new(songs: [], hit: nil)).prepopulate! }
 
-  it { subject.songs.size.must_equal 0 }
+  it { assert_equal subject.songs.size, 0 }
 end
 
-
 class ManualPrepopulatorOverridingTest < MiniTest::Spec
   Song = Struct.new(:title, :band, :length)
   Band = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :title
     property :length
 
@@ -105,8 +104,8 @@ class ManualPrepopulatorOverridingTest < MiniTest::Spec
   it do
     form = AlbumForm.new(OpenStruct.new(length: 1)).prepopulate!(title: "Potemkin City Limits")
 
-    form.length.must_equal 1
-    form.hit.model.must_equal Song.new("Potemkin City Limits")
-    form.hit.title.must_equal "Potemkin City Limits"
+    assert_equal form.length, 1
+    assert_equal form.hit.model, Song.new("Potemkin City Limits")
+    assert_equal form.hit.title, "Potemkin City Limits"
   end
-end
+end

data/test/read_only_test.rb

@@ -1,3 +1,14 @@
-require 'test_helper'
+require "test_helper"
 
+class ReadonlyTest < MiniTest::Spec
+  class SongForm < TestForm
+    property :artist
+    property :title, writeable: false
+    # TODO: what to do with virtual values?
+  end
 
+  let(:form) { SongForm.new(OpenStruct.new) }
+
+  it { refute form.readonly?(:artist) }
+  it { assert form.readonly?(:title) }
+end