reform 2.2.4 → 2.3.3

data/test/{module_test.rb → module_new_api.rb}

@@ -1,5 +1,5 @@
 require "test_helper"
-require 'reform/form/coercion'
+require "reform/form/coercion"
 
 class ModuleInclusionTest < MiniTest::Spec
   module BandPropertyForm
@@ -9,7 +9,7 @@ class ModuleInclusionTest < MiniTest::Spec
       property :title
 
       validation do
-        key(:title).required
+        params { required(:title).filled }
       end
 
       def id # gets mixed into Form, too.
@@ -22,11 +22,11 @@ class ModuleInclusionTest < MiniTest::Spec
     end
 
     validation do
-      key(:band).required
+      params { required(:band).filled }
     end
 
     include Dry::Types.module # allows using Types::* in module.
-    property :cool, type: Form::Bool # test coercion.
+    property :cool, type: DRY_TYPES_CONSTANT::Bool # test coercion.
   end
 
   # TODO: test if works, move stuff into inherit_schema!
@@ -36,53 +36,50 @@ class ModuleInclusionTest < MiniTest::Spec
     collection :airplays do
       property :station
       validation do
-        key(:station).required
+        params { required(:station).filled }
       end
     end
     validation do
-      key(:airplays).required
+      params { 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 < Reform::Form
+  class HitForm < TestForm
     include BandPropertyForm
   end
 
-  class SongForm < Reform::Form
+  class SongForm < TestForm
     include Coercion
     property :title
 
     include BandPropertyForm
   end
 
-
-  let (:song) { OpenStruct.new(:band => OpenStruct.new(:title => "Time Again")) }
+  let(:song) { OpenStruct.new(band: OpenStruct.new(title: "Time Again")) }
 
   # nested form from module is present and creates accessor.
-  it { SongForm.new(song).band.title.must_equal "Time Again" }
+  it { _(SongForm.new(song).band.title).must_equal "Time Again" }
 
   # methods from module get included.
-  it { SongForm.new(song).id.must_equal 1 }
-  it { SongForm.new(song).band.id.must_equal 2 }
+  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({})
-    form.errors.messages.must_equal({:band=>["is missing"]})
+    _(form.errors.messages).must_equal(band: ["must be filled"])
   end
 
   # coercion works
   it do
     form = SongForm.new(OpenStruct.new)
-    form.validate({cool: "1"})
-    form.cool.must_equal true
+    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
@@ -90,29 +87,28 @@ class ModuleInclusionTest < MiniTest::Spec
 
     property :name
     validation do
-      key(:name).required
+      params { required(:name).filled }
     end
   end
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     include AlbumFormModule
 
     # pp heritage
-    property :band, :inherit => true do
+    property :band, inherit: true do
       property :label
       validation do
-        key(:label).required
+        params { 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=>["must be filled"], :"band.title"=>["is missing"], :"band.label"=>["is missing"], :name=>["is missing"]})
+    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
@@ -127,16 +123,15 @@ class ModuleInclusionTest < MiniTest::Spec
       end
     end
 
-    class IncludingSongForm < Reform::Form
+    class IncludingSongForm < TestForm
       include SongModule
     end
 
-    let (:song) { OpenStruct.new(id: 1, title: "Instant Mash") }
+    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"
+      _(IncludingSongForm.new(song).id).must_equal 1
+      _(IncludingSongForm.new(song).title).must_equal "INSTANT MASH"
     end
   end
 end
-

data/test/module_old_api.rb

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

@@ -0,0 +1,40 @@
+require "test_helper"
+
+class ParseOptionTest < MiniTest::Spec
+  Comment = Struct.new(:content, :user)
+  User    = Struct.new(:name)
+
+  class CommentForm < TestForm
+    property :content
+    property :user, parse: false
+  end
+
+  let(:current_user) { User.new("Peter") }
+  let(:form) { CommentForm.new(Comment.new, user: current_user) }
+
+  it do
+    _(form.user).must_equal current_user
+
+    lorem = "Lorem ipsum dolor sit amet..."
+    form.validate("content" => lorem, "user" => "not the current user")
+
+    _(form.content).must_equal lorem
+    _(form.user).must_equal current_user
+  end
+
+  describe "using ':parse' option doesn't override other ':deserialize' options" do
+    class ArticleCommentForm < TestForm
+      property :content
+      property :article, deserializer: {instance: "Instance"}
+      property :user, parse: false, deserializer: {instance: "Instance"}
+    end
+
+    it do
+      _(ArticleCommentForm.definitions.get(:user)[:deserializer][:writeable]).must_equal false
+      _(ArticleCommentForm.definitions.get(:user)[:deserializer][:instance]).must_equal "Instance"
+
+      _(ArticleCommentForm.definitions.get(:article)[:deserializer][:writeable]).must_equal true
+      _(ArticleCommentForm.definitions.get(:article)[:deserializer][:instance]).must_equal "Instance"
+    end
+  end
+end

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\"}"
+    _(form.name).must_equal "{\"name\"=>\"Greatest Hits\"}"
   end
-end
+end

data/test/populate_new_api.rb

@@ -0,0 +1,304 @@
+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
+      params { required(:name).filled }
+    end
+
+    collection :songs,
+               populator: ->(fragment:, model:, index:, **) {
+                 (item = model[index]) ? item : model.insert(index, Song.new)
+               } do
+      property :title
+      validation do
+        params { required(:title).filled }
+      end
+
+      property :composer, populator: ->(options) { options[:model] || self.composer = Artist.new } do
+        property :name
+        validation do
+          params { 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
+        params { required(:title).filled }
+      end
+
+      property :composer, populate_if_empty: :populate_composer! do # lambda works, too. in form context.
+        property :name
+        validation do
+          params { 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
+        params { 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