reform 1.2.6 → 2.0.0.beta1

data/test/model_reflections_test.rb

@@ -85,7 +85,7 @@ class ModelReflectionTest < MiniTest::Spec
     # delegate to model class.
     it do
       reflection = form.class.reflect_on_association(:artist)
-      reflection.must_be_instance_of ActiveRecord::Reflection::AssociationReflection
+      reflection.must_be_kind_of ActiveRecord::Reflection::AssociationReflection
     end
   end
 

data/test/populate_test.rb

@@ -0,0 +1,226 @@
+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 < Reform::Form
+    property :name
+    validates :name, presence: true
+
+    collection :songs,
+      populator: lambda { |fragment, collection, index, options|
+        # collection = options.binding.get # we don't need this anymore as this comes in for free!
+        (item = collection[index]) ? item : collection.insert(index, Song.new) } do
+
+      property :title
+      validates :title, presence: true
+
+      property :composer, populator: lambda { |fragment, model, options| model || self.composer= Artist.new } do
+        property :name
+        validates :name, presence: true
+      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: lambda { |fragment, twin, *| twin || 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) }
+
+  # 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 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 < Reform::Form
+    property :name
+
+    collection :songs,
+      populate_if_empty: Song do                                                # class name works.
+
+      property :title
+      validates :title, presence: true
+
+      property :composer, populate_if_empty: :populate_composer! do # lambda works, too. in form context.
+        property :name
+        validates :name, presence: true
+      end
+
+    private
+      def populate_composer!(fragment, options)
+        Artist.new
+      end
+    end
+
+    property :artist, populate_if_empty: lambda { |*args| create_artist(args) } do # methods work, too.
+      property :name
+    end
+
+  private
+    class Sting < Artist
+      attr_accessor :args
+    end
+    def create_artist(args)
+      Sting.new.tap { |artist| artist.args=(args) }
+    end
+  end
+
+  let (:form) { AlbumForm.new(album) }
+
+  it 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].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 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\"}, {}]"
+
+    album.artist.must_equal nil
+  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 < Reform::Form
+    property :name
+
+    collection :songs,
+      populate_if_empty: Song, skip_if: :delete_song! do
+
+      property :title
+      validates :title, presence: true
+    end
+
+    def delete_song!(fragment, *)
+      songs.delete(songs[0]) and return true if 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

data/test/prepopulator_test.rb

@@ -0,0 +1,112 @@
+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.
+    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 :name
+      end
+
+      def my_band(name)
+        Band.new(title)
+      end
+    end
+
+    collection :songs, prepopulator: :prepopulate_songs! do
+        property :title
+    end
+
+  private
+    def prepopulate_songs!(options)
+      if songs == nil
+        self.songs = [Song.new, Song.new]
+      else
+        songs << Song.new # full Twin::Collection API available.
+      end
+    end
+  end
+
+  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
+    # 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")
+  end
+
+  # add to existing collection.
+  it do
+    form = AlbumForm.new(OpenStruct.new(songs: [Song.new])).prepopulate!
+
+    form.songs.size.must_equal 2
+    form.songs[0].model.must_equal Song.new
+    form.songs[1].model.must_equal Song.new
+  end
+end
+
+# calling form.prepopulate! shouldn't crash.
+class PrepopulateWithoutConfiguration < MiniTest::Spec
+  Song = Struct.new(:title)
+
+  class AlbumForm < Reform::Form
+    collection :songs do
+      property :title
+    end
+
+    property :hit do
+      property :title
+    end
+  end
+
+  subject { AlbumForm.new(OpenStruct.new(songs: [], hit: nil)).prepopulate! }
+
+  it { subject.songs.size.must_equal 0 }
+end
+
+
+class ManualPrepopulatorOverridingTest < MiniTest::Spec
+  Song = Struct.new(:title, :band, :length)
+  Band = Struct.new(:name)
+
+  class AlbumForm < Reform::Form
+    property :title
+    property :length
+
+    property :hit do
+      property :title
+
+      property :band do
+        property :name
+      end
+    end
+
+    def prepopulate!(options)
+      self.hit = Song.new(options[:title])
+      super
+    end
+  end
+
+  # you can simply override Form#prepopulate!
+  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"
+  end
+end

data/test/readable_test.rb

@@ -4,8 +4,6 @@ class ReadableTest < MiniTest::Spec
   Credentials = Struct.new(:password)
 
   class PasswordForm < Reform::Form
-    reform_2_0!
-
     property :password, readable: false
   end
 
@@ -13,14 +11,14 @@ class ReadableTest < MiniTest::Spec
   let (:form) { PasswordForm.new(cred) }
 
   it {
-    form.password.must_equal nil
+    form.password.must_equal nil # password not read.
 
     form.validate("password" => "123")
 
     form.password.must_equal "123"
 
     form.sync
-    cred.password.must_equal "123"
+    cred.password.must_equal "123" # password written.
 
     hash = {}
     form.save do |nested|

data/test/save_test.rb

@@ -1,139 +1,83 @@
 require 'test_helper'
 
 class SaveTest < BaseTest
-  class AlbumForm < Reform::Form
-    property :title
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
 
-    property :hit do
-      property :title
-      validates :title, :presence => true
-    end
+  class AlbumForm < Reform::Form
+    property :name
+    validates :name, presence: true
 
     collection :songs do
       property :title
-      validates :title, :presence => true
-    end
+      validates :title, presence: true
 
-    property :band do # yepp, people do crazy stuff like that.
-      property :label do
+      property :composer do
         property :name
-        validates :name, :presence => true
+        validates :name, presence: true
       end
-      # TODO: make band a required object.
     end
 
-    validates :title, :presence => true
+    property :artist, save: false do
+      property :name
+    end
   end
 
-  let (:params) {
-    {
-      "title" => "Best Of",
-      "hit"   => {"title" => "Roxanne"},
-      "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"}],
-      :band  => {:label => {:name => "Polydor"}}
-    }
-  }
-
-  let (:album) { Album.new(nil, hit, [song1, song2], band) }
-  let (:hit) { Song.new }
-  let (:song1) { Song.new }
-  let (:song2) { Song.new }
-  let (:band) { Band.new(label) }
-  let (:label) { Label.new }
-
-  subject { AlbumForm.new(album) }
-
-  before do
-    [album, hit, song1, song2, band, label].each { |mdl| mdl.extend(Saveable) }
-
-    subject.validate(params)
-    subject.save
-  end
+  module Saveable
+    def save
+      @saved = true
+    end
 
-  # synced?
-  it { album.title.must_equal "Best Of" }
-  it { hit.title.must_equal "Roxanne" }
-  it { song1.title.must_equal "Fallout" }
-  it { song2.title.must_equal "Roxanne" }
-  it { label.name.must_equal "Polydor" }
-
-  # saved?
-  it { album.saved?.must_equal true }
-  it { hit.saved?.must_equal true }
-  it { song1.saved?.must_equal true }
-  it { song1.saved?.must_equal true }
-  it { band.saved?.must_equal true }
-  it { label.saved?.must_equal true }
-
-
-  describe "save: false" do
-    let (:form) {
-      Class.new(Reform::Form) do
-        property :hit do
-          property :title
-        end
-
-        collection :songs, :save => false do
-          property :title
-        end
-
-        property :band do # yepp, people do crazy stuff like that.
-          property :label, :save => false do
-            property :name
-          end
-          # TODO: make band a required object.
-        end
-      end
-    }
-
-    subject { form.new(album) }
-
-    # synced?
-    it { hit.title.must_equal "Roxanne" }
-    it { song1.title.must_equal "Fallout" }
-    it { song2.title.must_equal "Roxanne" }
-    it { label.name.must_equal "Polydor" }
-
-    # saved?
-    it { album.saved?.must_equal true }
-    it { hit.saved?.must_equal true }
-    it { song1.saved?.must_equal nil }
-    it { song1.saved?.must_equal nil }
-    it { band.saved?.must_equal true }
-    it { label.saved?.must_equal nil }
+    def saved?
+      @saved
+    end
   end
 
 
-  # #save returns result (this goes into disposable soon).
-  it { subject.save.must_equal true }
+  let (:song)               { Song.new("Broken").extend(Saveable) }
+  # let (:song_with_composer) { Song.new("Resist Stance", nil, composer).extend(Saveable) }
+  let (:composer)           { Artist.new("Greg Graffin").extend(Saveable) }
+  let (:artist)             { Artist.new("Bad Religion").extend(Saveable).extend(Saveable) }
+  let (:album)              { Album.new("The Dissent Of Man", [song], artist).extend(Saveable) }
+
+  let (:form) { AlbumForm.new(album) }
+
+
   it do
-    album.instance_eval { def save; false; end }
-    subject.save.must_equal false
+    form.validate("songs" => [{"title" => "Fixed"}])
+
+    form.save
+
+    album.saved?.must_equal true
+    album.songs[0].title.must_equal "Fixed"
+    album.songs[0].saved?.must_equal true
+    album.artist.saved?.must_equal nil
   end
 end
 
 
-class SaveWithDynamicOptionsTest < MiniTest::Spec
-  Song = Struct.new(:id, :title, :length) do
-    include Saveable
-  end
+# class SaveWithDynamicOptionsTest < MiniTest::Spec
+#   Song = Struct.new(:id, :title, :length) do
+#     include Saveable
+#   end
 
-  class SongForm < Reform::Form
-    property :title#, save: false
-    property :length, virtual: true
-  end
+#   class SongForm < Reform::Form
+#     property :title#, save: false
+#     property :length, virtual: true
+#   end
 
-  let (:song) { Song.new }
-  let (:form) { SongForm.new(song) }
+#   let (:song) { Song.new }
+#   let (:form) { SongForm.new(song) }
 
-  # we have access to original input value and outside parameters.
-  it "xxx" do
-    form.validate("title" => "A Poor Man's Memory", "length" => 10)
-    length_seconds = 120
-    form.save(length: lambda { |value, options| form.model.id = "#{value}: #{length_seconds}" })
+#   # we have access to original input value and outside parameters.
+#   it "xxx" do
+#     form.validate("title" => "A Poor Man's Memory", "length" => 10)
+#     length_seconds = 120
+#     form.save(length: lambda { |value, options| form.model.id = "#{value}: #{length_seconds}" })
 
-    song.title.must_equal "A Poor Man's Memory"
-    song.length.must_equal nil
-    song.id.must_equal "10: 120"
-  end
-end
+#     song.title.must_equal "A Poor Man's Memory"
+#     song.length.must_equal nil
+#     song.id.must_equal "10: 120"
+#   end
+# end