reform 2.2.4 → 2.3.1

data/test/{call_test.rb → call_old_api.rb}

@@ -3,15 +3,15 @@ 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
+      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 }
@@ -19,5 +19,5 @@ class CallTest < Minitest::Spec
   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"]}) }
+  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,11 +18,11 @@ 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
@@ -38,4 +38,4 @@ class ChangedTest < MiniTest::Spec
     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,34 +25,51 @@ 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" }
 
-
-  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
@@ -58,9 +77,22 @@ class CoercionTest < BaseTest
 
     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.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_test.rb → composition_old_api.rb}

@@ -1,56 +1,92 @@
-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 { 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 < 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
+      required(:name).filled
+      required(:title).filled
     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 { assert_nil form.channel }
   it { form.requester.must_equal "MCP" } # same name as composed model.
-  it { form.captcha.must_equal nil }
+  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 { form.model[:song].must_equal song }
 
   it "creates Composition for you" do
-    form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb").must_equal false
+    form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb").must_equal true
+    form.validate("title" => "", "name" => "Frenzal Rhomb").must_equal false
   end
 
   describe "#save" do
@@ -63,7 +99,7 @@ class FormCompositionTest < MiniTest::Spec
         hash[:title]  = form.title
       end
 
-      hash.must_equal({:name=>"Duran Duran", :title=>"Rio"})
+      hash.must_equal({name: "Duran Duran", title: "Rio"})
     end
 
     it "provides nested symbolized hash as second block argument" do
@@ -76,9 +112,9 @@ class FormCompositionTest < MiniTest::Spec
       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"}
-        }
+                        song: {"title" => "Greyhound", "id" => 1, "channel" => "JJJ", "captcha" => "wonderful", "band" => {"title" => "Duran^2"}},
+                        requester: {"name" => "Frenzal Rhomb", "id" => 2, "requester" => "MCP"}
+                      }
       )
     end
 
@@ -124,16 +160,15 @@ class FormCompositionTest < MiniTest::Spec
   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 +177,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| hash.must_equal({library: {"books" => [{"id" => 1, "name" => "My book"}]}}) } }
 end