reform 2.2.4 → 2.6.2

data/test/benchmarking.rb

@@ -1,15 +1,48 @@
-require 'reform'
-require 'ostruct'
-require 'benchmark'
+require "reform"
+require "benchmark/ips"
+require "reform/form/dry"
 
 class BandForm < Reform::Form
-  property :name, validates: {presence: true}
+  feature Reform::Form::Dry
+  property :name #, validates: {presence: true}
+  collection :songs do
+    property :title #, validates: {presence: true}
+  end
+end
 
+class OptimizedBandForm < Reform::Form
+  feature Reform::Form::Dry
+  property :name #, validates: {presence: true}
   collection :songs do
-    property :title, validates: {presence: true}
+    property :title #, validates: {presence: true}
+
+  	def deserializer(*args)
+      # DISCUSS: should we simply delegate to class and sort out memoizing there?
+      self.class.deserializer_class || self.class.deserializer_class = deserializer!(*args)
+  	end
+  end
+
+  def deserializer(*args)
+    # DISCUSS: should we simply delegate to class and sort out memoizing there?
+    self.class.deserializer_class || self.class.deserializer_class = deserializer!(*args)
   end
 end
 
+songs = 10.times.collect { OpenStruct.new(title: "Be Stag") }
+band = OpenStruct.new(name: "Teenage Bottlerock", songs: songs)
+
+unoptimized_form = BandForm.new(band)
+optimized_form   = OptimizedBandForm.new(band)
+
+songs_params = songs_params = 10.times.collect { {title: "Commando"} }
+
+Benchmark.ips do |x|
+   x.report("2.2") { BandForm.new(band).validate("name" => "Ramones", "songs" => songs_params) }
+   x.report("2.3") { OptimizedBandForm.new(band).validate("name" => "Ramones", "songs" => songs_params)  }
+end
+
+exit
+
 songs = 50.times.collect { OpenStruct.new(title: "Be Stag") }
 band = OpenStruct.new(name: "Teenage Bottlerock", songs: songs)
 
@@ -23,4 +56,4 @@ time = Benchmark.measure do
   end
 end
 
-puts time
+puts time

data/test/call_test.rb

@@ -3,21 +3,21 @@ require "test_helper"
 class CallTest < Minitest::Spec
   Song = Struct.new(:title)
 
-  class SongForm < Reform::Form
+  class SongForm < TestForm
     property :title
 
     validation do
-      key(:title).required
+      params { required(:title).filled }
     end
   end
 
-  let (:form) { SongForm.new(Song.new) }
+  let(:form) { SongForm.new(Song.new) }
 
-  it { form.(title: "True North").success?.must_equal true }
-  it { form.(title: "True North").failure?.must_equal false }
-  it { form.(title: "").success?.must_equal false }
-  it { form.(title: "").failure?.must_equal true }
+  it { assert form.(title: "True North").success? }
+  it { refute form.(title: "True North").failure? }
+  it { refute form.(title: "").success? }
+  it { assert form.(title: "").failure? }
 
-  it { form.(title: "True North").errors.messages.must_equal({}) }
-  it { form.(title: "").errors.messages.must_equal({:title=>["must be filled"]}) }
+  it { assert_equal form.(title: "True North").errors.messages, {} }
+  it { assert_equal form.(title: "").errors.messages, title: ["must be filled"] }
 end

data/test/changed_test.rb

@@ -1,12 +1,12 @@
-require 'test_helper'
-require 'reform/form/coercion'
+require "test_helper"
+require "reform/form/coercion"
 
 class ChangedTest < MiniTest::Spec
   Song  = Struct.new(:title, :album, :composer)
   Album = Struct.new(:name, :songs, :artist)
   Artist = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :name
 
     collection :songs do
@@ -18,24 +18,24 @@ class ChangedTest < MiniTest::Spec
     end
   end
 
-  let (:song_with_composer) { Song.new("Resist Stance", nil, composer) }
-  let (:composer)           { Artist.new("Greg Graffin") }
-  let (:album)              { Album.new("The Dissent Of Man", [song_with_composer]) }
+  let(:song_with_composer) { Song.new("Resist Stance", nil, composer) }
+  let(:composer)           { Artist.new("Greg Graffin") }
+  let(:album)              { Album.new("The Dissent Of Man", [song_with_composer]) }
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   # nothing changed after setup.
   it do
-    form.changed?(:name).must_equal false
-    form.songs[0].changed?(:title).must_equal false
-    form.songs[0].composer.changed?(:name).must_equal false
+    refute form.changed?(:name)
+    refute form.songs[0].changed?(:title)
+    refute form.songs[0].composer.changed?(:name)
   end
 
   # after validate, things might have changed.
   it do
     form.validate("name" => "Out Of Bounds", "songs" => [{"composer" => {"name" => "Ingemar Jansson & Mikael Danielsson"}}])
-    form.changed?(:name).must_equal true
-    form.songs[0].changed?(:title).must_equal false
-    form.songs[0].composer.changed?(:name).must_equal true
+    assert form.changed?(:name)
+    refute form.songs[0].changed?(:title)
+    assert form.songs[0].composer.changed?(:name)
   end
-end
+end

data/test/coercion_test.rb

@@ -1,21 +1,23 @@
 require "test_helper"
 require "reform/form/coercion"
+require "disposable/twin/property/hash"
 
 class CoercionTest < BaseTest
   class Irreversible
     def self.call(value)
-      value*2
+      value * 2
     end
   end
 
-  class Form < Reform::Form
+  class Form < TestForm
     feature Coercion
+    include Disposable::Twin::Property::Hash
 
-    property :released_at, type: Types::Form::DateTime
+    property :released_at, type: Types::Params::DateTime
 
     property :hit do
-      property :length, type: Types::Form::Int
-      property :good,   type: Types::Form::Bool
+      property :length, type: Types::Params::Integer
+      property :good,   type: Types::Params::Bool
     end
 
     property :band do
@@ -23,44 +25,74 @@ class CoercionTest < BaseTest
         property :value, type: Irreversible
       end
     end
+
+    property :metadata, field: :hash do
+      property :publication_settings do
+        property :featured, type: Types::Params::Bool
+      end
+    end
   end
 
   subject do
     Form.new(album)
   end
 
-  let (:album) {
+  let(:album) do
     OpenStruct.new(
-      :released_at => "31/03/1981",
-      :hit         => OpenStruct.new(:length => "312"),
-      :band        => Band.new(OpenStruct.new(:value => "9999.99"))
+      released_at: "31/03/1981",
+      hit: OpenStruct.new(length: "312"),
+      band: Band.new(OpenStruct.new(value: "9999.99")),
+      metadata: {}
     )
-  }
+  end
 
   # it { subject.released_at.must_be_kind_of DateTime }
-  it { subject.released_at.must_equal "31/03/1981" } # NO coercion in setup.
-  it { subject.hit.length.must_equal "312" }
-  it { subject.band.label.value.must_equal "9999.99" }
-
+  it { assert_equal subject.released_at, "31/03/1981" } # NO coercion in setup.
+  it { assert_equal subject.hit.length, "312" }
+  it { assert_equal subject.band.label.value, "9999.99" }
 
-  let (:params) {
+  let(:params) do
     {
-      :released_at => "30/03/1981",
-      :hit         => {:length => "312"},
-      :band        => {:label => {:value => "9999.99"}}
+      released_at: "30/03/1981",
+      hit: {
+        length: "312",
+        good: "0",
+      },
+      band: {
+        label: {
+          value: "9999.99"
+        }
+      },
+      metadata: {
+        publication_settings: {
+          featured: "0"
+        }
+      }
     }
-  }
-
+  end
 
   # validate
   describe "#validate" do
     before { subject.validate(params) }
 
-    it { subject.released_at.must_equal DateTime.parse("30/03/1981") }
-    it { subject.hit.length.must_equal 312 }
-    it { subject.hit.good.must_equal nil }
-    it { subject.band.label.value.must_equal "9999.999999.99" } # coercion happened once.
+    it { assert_equal subject.released_at, DateTime.parse("30/03/1981") }
+    it { assert_equal subject.hit.length, 312 }
+    it { assert_equal subject.hit.good, false }
+    it { assert_equal subject.band.label.value, "9999.999999.99" } # coercion happened once.
+    it { assert_equal subject.metadata.publication_settings.featured, false }
   end
 
-  # save
+  # sync
+  describe "#sync" do
+    before do
+      assert subject.validate(params)
+      subject.sync
+    end
+
+    it { assert_equal album.released_at, DateTime.parse("30/03/1981") }
+    it { assert_equal album.hit.length, 312 }
+    it { assert_equal album.hit.good, false }
+    it { assert_nil album.metadata[:publication_settings] }
+    it { assert_equal album.metadata["publication_settings"]["featured"], false }
+  end
 end

data/test/composition_test.rb

@@ -1,56 +1,94 @@
-require 'test_helper'
+require "test_helper"
+
+class FormCompositionInheritanceTest < MiniTest::Spec
+  module SizePrice
+    include Reform::Form::Module
+
+    property :price
+    property :size
+
+    module InstanceMethods
+      def price(for_size: size)
+        case for_size.to_sym
+          when :s then super() * 1
+          when :m then super() * 2
+          when :l then super() * 3
+        end
+      end
+    end
+  end
+
+  class OutfitForm < TestForm
+    include Reform::Form::Composition
+    include SizePrice
+
+    property :price,  inherit: true, on: :tshirt
+    property :size,   inherit: true, on: :measurement
+  end
+
+  let(:measurement) { Measurement.new(:l) }
+  let(:tshirt)      { Tshirt.new(2, :m) }
+  let(:form)        { OutfitForm.new(tshirt: tshirt, measurement: measurement) }
+
+  Tshirt = Struct.new(:price, :size)
+  Measurement = Struct.new(:size)
+
+  it { assert_equal form.price, 6 }
+  it { assert_equal form.price(for_size: :s), 2 }
+end
 
 class FormCompositionTest < MiniTest::Spec
   Song      = Struct.new(:id, :title, :band)
   Requester = Struct.new(:id, :name, :requester)
   Band      = Struct.new(:title)
 
-  class RequestForm < Reform::Form
+  class RequestForm < TestForm
     include Composition
 
-    property  :name,          :on =>  :requester
-    property  :requester_id,  :on => :requester, :from => :id
-    properties :title, :id, :on => :song
+    property  :name,          on: :requester
+    property  :requester_id,  on: :requester, from: :id
+    properties :title, :id, on: :song
     # property  :channel # FIXME: what about the "main model"?
-    property :channel, :virtual => true, :on => :song
-    property :requester,      :on => :requester
-    property :captcha,        :on => :song, :virtual => true
+    property :channel, virtual: true, on: :song
+    property :requester,      on: :requester
+    property :captcha,        on: :song, virtual: true
 
     validation do
-      key(:name).required
-      key(:name).required
-      key(:title).required
+      params do
+        required(:name).filled
+        required(:title).filled
+      end
     end
 
-    property :band,           :on => :song do
+    property :band, on: :song do
       property :title
     end
   end
 
-  let (:form)       { RequestForm.new(:song => song, :requester => requester) }
-  let (:song)       { Song.new(1, "Rio", band) }
-  let (:requester)  { Requester.new(2, "Duran Duran", "MCP") }
-  let (:band)       { Band.new("Duran^2") }
+  let(:form)       { RequestForm.new(song: song, requester: requester) }
+  let(:song)       { Song.new(1, "Rio", band) }
+  let(:requester)  { Requester.new(2, "Duran Duran", "MCP") }
+  let(:band)       { Band.new("Duran^2") }
 
   # delegation form -> composition works
-  it { form.id.must_equal 1 }
-  it { form.title.must_equal "Rio" }
-  it { form.name.must_equal "Duran Duran" }
-  it { form.requester_id.must_equal 2 }
-  it { form.channel.must_equal nil }
-  it { form.requester.must_equal "MCP" } # same name as composed model.
-  it { form.captcha.must_equal nil }
+  it { assert_equal form.id, 1 }
+  it { assert_equal form.title, "Rio" }
+  it { assert_equal form.name, "Duran Duran" }
+  it { assert_equal form.requester_id, 2 }
+  it { assert_nil form.channel }
+  it { assert_equal form.requester, "MCP" } # same name as composed model.
+  it { assert_nil form.captcha }
 
   # #model just returns <Composition>.
-  it { form.mapper.must_be_kind_of Disposable::Composition }
+  it { assert form.mapper.is_a? Disposable::Composition }
 
   # #model[] -> composed models
-  it { form.model[:requester].must_equal requester }
-  it { form.model[:song].must_equal      song }
-
+  it { assert_equal form.model[:requester], requester }
+  it { assert_equal form.model[:song], song }
 
   it "creates Composition for you" do
-    form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb").must_equal false
+    assert_equal form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb"), true
+    assert_equal form.validate("title" => "", "name" => "Frenzal Rhomb"), false
   end
 
   describe "#save" do
@@ -63,7 +101,7 @@ class FormCompositionTest < MiniTest::Spec
         hash[:title]  = form.title
       end
 
-      hash.must_equal({:name=>"Duran Duran", :title=>"Rio"})
+      assert_equal hash, name: "Duran Duran", title: "Rio"
     end
 
     it "provides nested symbolized hash as second block argument" do
@@ -75,11 +113,10 @@ class FormCompositionTest < MiniTest::Spec
         hash = map
       end
 
-      hash.must_equal({
-        :song=>{"title"=>"Greyhound", "id"=>1, "channel" => "JJJ", "captcha"=>"wonderful", "band"=>{"title"=>"Duran^2"}},
-        :requester=>{"name"=>"Frenzal Rhomb", "id"=>2, "requester" => "MCP"}
-        }
-      )
+      assert_equal hash, {
+        song: {"title" => "Greyhound", "id" => 1, "channel" => "JJJ", "captcha" => "wonderful", "band" => {"title" => "Duran^2"}},
+        requester: {"name" => "Frenzal Rhomb", "id" => 2, "requester" => "MCP"}
+      }
     end
 
     it "xxx pushes data to models and calls #save when no block passed" do
@@ -88,16 +125,16 @@ class FormCompositionTest < MiniTest::Spec
       band.extend(Saveable)
 
       form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "captcha" => "1337")
-      form.captcha.must_equal "1337" # TODO: move to separate test.
+      assert_equal form.captcha, "1337" # TODO: move to separate test.
 
       form.save
 
-      requester.name.must_equal "Frenzal Rhomb"
-      requester.saved?.must_equal true
-      song.title.must_equal "Greyhound"
-      song.saved?.must_equal true
-      song.band.title.must_equal "Duran^2"
-      song.band.saved?.must_equal true
+      assert_equal requester.name, "Frenzal Rhomb"
+      assert_equal requester.saved?, true
+      assert_equal song.title, "Greyhound"
+      assert_equal song.saved?, true
+      assert_equal song.band.title, "Duran^2"
+      assert_equal song.band.saved?, true
     end
 
     it "returns true when models all save successfully" do
@@ -105,7 +142,7 @@ class FormCompositionTest < MiniTest::Spec
       requester.extend(Saveable)
       band.extend(Saveable)
 
-      form.save.must_equal true
+      assert_equal form.save, true
     end
 
     it "returns false when one or more models don't save successfully" do
@@ -119,21 +156,20 @@ class FormCompositionTest < MiniTest::Spec
       requester.extend(Saveable)
       band.extend(Saveable)
 
-      form.save.must_equal false
+      assert_equal form.save, false
     end
   end
 end
 
-
 class FormCompositionCollectionTest < MiniTest::Spec
   Book = Struct.new(:id, :name)
   Library = Struct.new(:id) do
     def books
-      [Book.new(1,"My book")]
+      [Book.new(1, "My book")]
     end
   end
 
-  class LibraryForm < Reform::Form
+  class LibraryForm < TestForm
     include Reform::Form::Composition
 
     collection :books, on: :library do
@@ -142,8 +178,8 @@ class FormCompositionCollectionTest < MiniTest::Spec
     end
   end
 
-  let (:form)   { LibraryForm.new(library: library) }
-  let (:library) { Library.new(2) }
+  let(:form)   { LibraryForm.new(library: library) }
+  let(:library) { Library.new(2) }
 
-  it { form.save do |hash| hash.must_equal({:library=>{"books"=>[{"id"=>1, "name"=>"My book"}]}}) end }
+  it { form.save { |hash| assert_equal hash, { library: { "books" => [{ "id" => 1, "name" => "My book" }] } } } }
 end

data/test/contract/custom_error_test.rb

@@ -0,0 +1,55 @@
+require "test_helper"
+
+class CustomerErrorTest < MiniTest::Spec
+  let(:key)            { :name }
+  let(:error_text)     { "text2" }
+  let(:starting_error) { [OpenStruct.new(errors: {title: ["text1"]})] }
+
+  let(:custom_error) { Reform::Contract::CustomError.new(key, error_text, @results) }
+
+  before { @results = starting_error }
+
+  it "base class structure" do
+    assert_equal custom_error.success?, false
+    assert_equal custom_error.failure?, true
+    assert_equal custom_error.errors, key => [error_text]
+    assert_equal custom_error.messages, key => [error_text]
+    assert_equal custom_error.hint, {}
+  end
+
+  describe "updates @results accordingly" do
+    it "add new key" do
+      custom_error
+
+      assert_equal @results.size, 2
+      errors = @results.map(&:errors)
+
+      assert_equal errors[0], starting_error.first.errors
+      assert_equal errors[1], custom_error.errors
+    end
+
+    describe "when key error already exists in @results" do
+      let(:key) { :title }
+
+      it "merge errors text" do
+        custom_error
+
+        assert_equal @results.size, 1
+
+        assert_equal @results.first.errors.values, [%w[text1 text2]]
+      end
+
+      describe "add error text is already" do
+        let(:error_text) { "text1" }
+
+        it 'does not create duplicates' do
+          custom_error
+
+          assert_equal @results.size, 1
+
+          assert_equal @results.first.errors.values, [%w[text1]]
+        end
+      end
+    end
+  end
+end

data/test/contract_test.rb

@@ -1,34 +1,34 @@
-require 'test_helper'
+require "test_helper"
 
 class ContractTest < MiniTest::Spec
   Song  = Struct.new(:title, :album, :composer)
   Album = Struct.new(:name, :duration, :songs, :artist)
   Artist = Struct.new(:name)
 
-  class ArtistForm < Reform::Form
+  class ArtistForm < TestForm
     property :name
   end
 
-  class AlbumForm < Reform::Contract
+  class AlbumForm < TestContract
     property :name
 
     properties :duration
     properties :year, :style, readable: false
 
     validation do
-      key(:name).required
+      params { required(:name).filled }
     end
 
     collection :songs do
       property :title
       validation do
-        key(:title).required
+        params { required(:title).filled }
       end
 
       property :composer do
         property :name
         validation do
-          key(:name).required
+          params { required(:name).filled }
         end
       end
     end
@@ -36,42 +36,42 @@ class ContractTest < MiniTest::Spec
     property :artist, form: ArtistForm
   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", 123, [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", 123, [song, song_with_composer], artist) }
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   # accept `property form: SongForm`.
   it do
-    form.artist.must_be_instance_of ArtistForm
+    assert form.artist.is_a? ArtistForm
   end
 
   describe ".properties" do
     it "defines a property when called with one argument" do
-      form.must_respond_to :duration
+      assert_respond_to form, :duration
     end
 
     it "defines several properties when called with multiple arguments" do
-      form.must_respond_to :year
-      form.must_respond_to :style
+      assert_respond_to form, :year
+      assert_respond_to form, :style
     end
 
     it "passes options to each property when options are provided" do
       readable = AlbumForm.new(album).options_for(:style)[:readable]
-      readable.must_equal false
+      assert_equal readable, false
     end
 
     it "returns the list of defined properties" do
       returned_value = AlbumForm.properties(:hello, :world, virtual: true)
-      returned_value.must_equal [:hello, :world]
+      assert_equal returned_value, %i[hello world]
     end
   end
 
   describe "#options_for" do
-    it { AlbumForm.options_for(:name).extend(Declarative::Inspect).inspect.must_equal "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
-    it { AlbumForm.new(album).options_for(:name).extend(Declarative::Inspect).inspect.must_equal "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
+    it { assert_equal AlbumForm.options_for(:name).extend(Declarative::Inspect).inspect, "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
+    it { assert_equal AlbumForm.new(album).options_for(:name).extend(Declarative::Inspect).inspect, "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
   end
 end

data/test/default_test.rb

@@ -5,7 +5,7 @@ class DefaultTest < Minitest::Spec
   Album = Struct.new(:name, :songs, :artist)
   Artist = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :name, default: "Wrong"
 
     collection :songs do
@@ -16,7 +16,7 @@ class DefaultTest < Minitest::Spec
   it do
     form = AlbumForm.new(Album.new(nil, [Song.new]))
 
-    form.name.must_equal "Wrong"
-    form.songs[0].title.must_equal "It's Catching Up"
+    assert_equal form.name, "Wrong"
+    assert_equal form.songs[0].title, "It's Catching Up"
   end
-end
+end