reform 2.2.4 → 2.3.3

data/test/call_old_api.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+class CallTest < Minitest::Spec
+  Song = Struct.new(:title)
+
+  class SongForm < TestForm
+    property :title
+
+    validation do
+      required(:title).filled
+    end
+  end
+
+  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 { _(form.(title: "True North").errors.messages).must_equal({}) }
+  it { _(form.(title: "").errors.messages).must_equal(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
+    _(form.changed?(:name)).must_equal false
+    _(form.songs[0].changed?(:title)).must_equal false
+    _(form.songs[0].composer.changed?(:name)).must_equal false
   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
+    _(form.changed?(:name)).must_equal true
+    _(form.songs[0].changed?(:title)).must_equal false
+    _(form.songs[0].composer.changed?(:name)).must_equal true
   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: DRY_TYPES_CONSTANT::DateTime
 
     property :hit do
-      property :length, type: Types::Form::Int
-      property :good,   type: Types::Form::Bool
+      property :length, type: DRY_TYPES_INT_CONSTANT
+      property :good,   type: DRY_TYPES_CONSTANT::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: DRY_TYPES_CONSTANT::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 { _(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" }
 
-  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 { _(subject.released_at).must_equal DateTime.parse("30/03/1981") }
+    it { _(subject.hit.length).must_equal 312 }
+    it { _(subject.hit.good).must_equal false }
+    it { _(subject.band.label.value).must_equal "9999.999999.99" } # coercion happened once.
+    it { _(subject.metadata.publication_settings.featured).must_equal false }
   end
 
-  # save
+  # sync
+  describe "#sync" do
+    before do
+      _(subject.validate(params)).must_equal true
+      subject.sync
+    end
+
+    it { _(album.released_at).must_equal DateTime.parse("30/03/1981") }
+    it { _(album.hit.length).must_equal 312 }
+    it { _(album.hit.good).must_equal false }
+    it { assert_nil album.metadata[:publication_settings] }
+    it { _(album.metadata["publication_settings"]["featured"]).must_equal false }
+  end
 end

data/test/composition_new_api.rb

@@ -0,0 +1,186 @@
+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 { _(form.price).must_equal 6 }
+  it { _(form.price(for_size: :s)).must_equal 2 }
+end
+
+class FormCompositionTest < MiniTest::Spec
+  Song      = Struct.new(:id, :title, :band)
+  Requester = Struct.new(:id, :name, :requester)
+  Band      = Struct.new(:title)
+
+  class RequestForm < TestForm
+    include Composition
+
+    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
+
+    validation do
+      params do
+        required(:name).filled
+        required(:title).filled
+      end
+    end
+
+    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") }
+
+  # 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 { assert_nil form.channel }
+  it { _(form.requester).must_equal "MCP" } # same name as composed model.
+  it { assert_nil form.captcha }
+
+  # #model just returns <Composition>.
+  it { _(form.mapper).must_be_kind_of Disposable::Composition }
+
+  # #model[] -> composed models
+  it { _(form.model[:requester]).must_equal requester }
+  it { _(form.model[:song]).must_equal song }
+
+  it "creates Composition for you" do
+    _(form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb")).must_equal true
+    _(form.validate("title" => "", "name" => "Frenzal Rhomb")).must_equal false
+  end
+
+  describe "#save" do
+    # #save with {}
+    it do
+      hash = {}
+
+      form.save do |map|
+        hash[:name]   = form.name
+        hash[:title]  = form.title
+      end
+
+      _(hash).must_equal({name: "Duran Duran", title: "Rio"})
+    end
+
+    it "provides nested symbolized hash as second block argument" do
+      form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "channel" => "JJJ", "captcha" => "wonderful")
+
+      hash = nil
+
+      form.save do |map|
+        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"}
+                      }
+      )
+    end
+
+    it "xxx pushes data to models and calls #save when no block passed" do
+      song.extend(Saveable)
+      requester.extend(Saveable)
+      band.extend(Saveable)
+
+      form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "captcha" => "1337")
+      _(form.captcha).must_equal "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
+    end
+
+    it "returns true when models all save successfully" do
+      song.extend(Saveable)
+      requester.extend(Saveable)
+      band.extend(Saveable)
+
+      _(form.save).must_equal true
+    end
+
+    it "returns false when one or more models don't save successfully" do
+      module Unsaveable
+        def save
+          false
+        end
+      end
+
+      song.extend(Unsaveable)
+      requester.extend(Saveable)
+      band.extend(Saveable)
+
+      _(form.save).must_equal 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")]
+    end
+  end
+
+  class LibraryForm < TestForm
+    include Reform::Form::Composition
+
+    collection :books, on: :library do
+      property :id
+      property :name
+    end
+  end
+
+  let(:form)   { LibraryForm.new(library: library) }
+  let(:library) { Library.new(2) }
+
+  it { form.save { |hash| _(hash).must_equal({library: {"books" => [{"id" => 1, "name" => "My book"}]}}) } }
+end

data/test/composition_old_api.rb

@@ -0,0 +1,184 @@
+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 { _(form.price).must_equal 6 }
+  it { _(form.price(for_size: :s)).must_equal 2 }
+end
+
+class FormCompositionTest < MiniTest::Spec
+  Song      = Struct.new(:id, :title, :band)
+  Requester = Struct.new(:id, :name, :requester)
+  Band      = Struct.new(:title)
+
+  class RequestForm < TestForm
+    include Composition
+
+    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
+
+    validation do
+      required(:name).filled
+      required(:title).filled
+    end
+
+    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") }
+
+  # 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 { assert_nil form.channel }
+  it { _(form.requester).must_equal "MCP" } # same name as composed model.
+  it { assert_nil form.captcha }
+
+  # #model just returns <Composition>.
+  it { _(form.mapper).must_be_kind_of Disposable::Composition }
+
+  # #model[] -> composed models
+  it { _(form.model[:requester]).must_equal requester }
+  it { _(form.model[:song]).must_equal song }
+
+  it "creates Composition for you" do
+    _(form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb")).must_equal true
+    _(form.validate("title" => "", "name" => "Frenzal Rhomb")).must_equal false
+  end
+
+  describe "#save" do
+    # #save with {}
+    it do
+      hash = {}
+
+      form.save do |map|
+        hash[:name]   = form.name
+        hash[:title]  = form.title
+      end
+
+      _(hash).must_equal({name: "Duran Duran", title: "Rio"})
+    end
+
+    it "provides nested symbolized hash as second block argument" do
+      form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "channel" => "JJJ", "captcha" => "wonderful")
+
+      hash = nil
+
+      form.save do |map|
+        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"}
+                      }
+      )
+    end
+
+    it "xxx pushes data to models and calls #save when no block passed" do
+      song.extend(Saveable)
+      requester.extend(Saveable)
+      band.extend(Saveable)
+
+      form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "captcha" => "1337")
+      _(form.captcha).must_equal "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
+    end
+
+    it "returns true when models all save successfully" do
+      song.extend(Saveable)
+      requester.extend(Saveable)
+      band.extend(Saveable)
+
+      _(form.save).must_equal true
+    end
+
+    it "returns false when one or more models don't save successfully" do
+      module Unsaveable
+        def save
+          false
+        end
+      end
+
+      song.extend(Unsaveable)
+      requester.extend(Saveable)
+      band.extend(Saveable)
+
+      _(form.save).must_equal 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")]
+    end
+  end
+
+  class LibraryForm < TestForm
+    include Reform::Form::Composition
+
+    collection :books, on: :library do
+      property :id
+      property :name
+    end
+  end
+
+  let(:form)   { LibraryForm.new(library: library) }
+  let(:library) { Library.new(2) }
+
+  it { form.save { |hash| _(hash).must_equal({library: {"books" => [{"id" => 1, "name" => "My book"}]}}) } }
+end