reform 2.2.4 → 2.3.1

data/test/{populate_test.rb → populate_old_api.rb}

@@ -5,27 +5,25 @@ class PopulatorTest < MiniTest::Spec
   Album = Struct.new(:name, :songs, :artist)
   Artist = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :name, populator: ->(options) { self.name = options[:fragment].reverse }
     validation do
-      key(:name).required
+      required(:name).filled
     end
 
     collection :songs,
-      populator: ->(options) {
-        fragment, collection, index = options[:fragment], options[:model], options[:index]
-
-        (item = collection[index]) ? item : collection.insert(index, Song.new) } do
-
+               populator: ->(fragment:, model:, index:, **) {
+                 (item = model[index]) ? item : model.insert(index, Song.new)
+               } do
       property :title
       validation do
-        key(:title).required
+        required(:title).filled
       end
 
-      property :composer, populator: ->(options) { options[:model] || self.composer= Artist.new } do
+      property :composer, populator: ->(options) { options[:model] || self.composer = Artist.new } do
         property :name
         validation do
-          key(:name).required
+          required(:name).filled
         end
       end
     end
@@ -37,13 +35,13 @@ class PopulatorTest < MiniTest::Spec
     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(: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) }
+  let(:form) { AlbumForm.new(album) }
 
   it "runs populator on scalar" do
     form.validate(
@@ -93,7 +91,6 @@ class PopulatorTest < MiniTest::Spec
     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"
@@ -107,7 +104,7 @@ end
 class PopulateWithMethodTest < Minitest::Spec
   Album = Struct.new(:title)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :title, populator: :title!
 
     def title!(options)
@@ -115,12 +112,54 @@ class PopulateWithMethodTest < Minitest::Spec
     end
   end
 
-  let (:form) { AlbumForm.new(Album.new) }
+  let(:form) { AlbumForm.new(Album.new) }
 
   it "runs populator method" do
-    form.validate(
-      "title" => "override me!"
-    )
+    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
@@ -131,15 +170,13 @@ class PopulateIfEmptyTest < MiniTest::Spec
   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) }
-
-
+  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
+  class AlbumForm < TestForm
     property :name
 
     collection :songs,
@@ -147,42 +184,42 @@ class PopulateIfEmptyTest < MiniTest::Spec
 
       property :title
       validation do
-        key(:title).required
+        required(:title).filled
       end
 
       property :composer, populate_if_empty: :populate_composer! do # lambda works, too. in form context.
         property :name
         validation do
-          key(:name).required
+          required(:name).filled
         end
       end
 
     private
-      def populate_composer!(fragment, options)
+      def populate_composer!(options)
         Artist.new
       end
     end
 
-    property :artist, populate_if_empty: lambda { |args| create_artist(args[:fragment], args[:user_options]) } do # methods work, too.
+    property :artist, populate_if_empty: ->(args) { create_artist(args[:fragment], args[:user_options]) } do # methods work, too.
       property :name
     end
 
-  private
+    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) }
+      Sting.new.tap { |artist| artist.args = ([input, user_options].to_s) }
     end
   end
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   it do
     form.songs.size.must_equal 2
 
     form.validate(
-      "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne"},
+      "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
@@ -201,7 +238,6 @@ class PopulateIfEmptyTest < MiniTest::Spec
     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"
@@ -222,22 +258,20 @@ class PopulateIfEmptyTest < MiniTest::Spec
     # test lambda block arguments.
     form.artist.model.args.to_s.must_equal "[{\"name\"=>\"From Autumn To Ashes\"}, nil]"
 
-    album.artist.must_equal 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]) }
-
+  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
+  class AlbumForm < TestForm
     property :name
 
     collection :songs,
@@ -245,7 +279,7 @@ class PopulateIfEmptyWithDeletionTest < MiniTest::Spec
 
       property :title
       validation do
-        key(:title).required
+        required(:title).filled
       end
     end
 
@@ -255,11 +289,11 @@ class PopulateIfEmptyWithDeletionTest < MiniTest::Spec
     end
   end
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   it do
     form.validate(
-      "songs"  => [{"title" => "Broken, delete me!"}, {"title" => "Roxanne"}]
+      "songs" => [{"title" => "Broken, delete me!"}, {"title" => "Roxanne"}]
     ).must_equal true
 
     form.errors.messages.inspect.must_equal "{}"

data/test/populator_skip_test.rb

@@ -4,14 +4,14 @@ class PopulatorSkipTest < MiniTest::Spec
   Album = Struct.new(:songs)
   Song  = Struct.new(:title)
 
+  class AlbumForm < TestForm
+    collection :songs, populator: :my_populator do
+      property :title
+    end
 
-  class AlbumForm < Reform::Form
-    collection :songs,
-      populator: ->(options) {
-        return skip! if options[:fragment][:title] == "Good"
-        songs[options[:index]]
-      } do
-        property :title
+    def my_populator(options)
+      return skip! if options[:fragment][:title] == "Good"
+      songs[options[:index]]
     end
   end
 
@@ -22,7 +22,7 @@ class PopulatorSkipTest < MiniTest::Spec
     form.validate(hash)
 
     form.songs.size.must_equal 2
-    form.songs[0].title.must_equal nil
+    assert_nil form.songs[0].title
     form.songs[1].title.must_equal "Bad"
   end
-end
+end

data/test/prepopulator_test.rb

@@ -1,17 +1,17 @@
-require 'test_helper'
+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.
+  class AlbumForm < TestForm
+    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 :band, prepopulator: ->(options) { self.band = my_band(options[:title]) } do                             # invoke your own code.
         property :name
       end
 
@@ -24,7 +24,7 @@ class PrepopulatorTest < MiniTest::Spec
         property :title
     end
 
-  private
+    private
     def prepopulate_songs!(options)
       if songs == nil
         self.songs = [Song.new, Song.new]
@@ -63,7 +63,7 @@ end
 class PrepopulateWithoutConfiguration < MiniTest::Spec
   Song = Struct.new(:title)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     collection :songs do
       property :title
     end
@@ -78,12 +78,11 @@ class PrepopulateWithoutConfiguration < MiniTest::Spec
   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
+  class AlbumForm < TestForm
     property :title
     property :length
 
@@ -109,4 +108,4 @@ class ManualPrepopulatorOverridingTest < MiniTest::Spec
     form.hit.model.must_equal Song.new("Potemkin City Limits")
     form.hit.title.must_equal "Potemkin City Limits"
   end
-end
+end

data/test/read_only_test.rb

@@ -1,3 +1,14 @@
-require 'test_helper'
+require "test_helper"
 
+class ReadonlyTest < MiniTest::Spec
+  class SongForm < TestForm
+    property :artist
+    property :title, writeable: false
+    # TODO: what to do with virtual values?
+  end
 
+  let(:form) { SongForm.new(OpenStruct.new) }
+
+  it { form.readonly?(:artist).must_equal false }
+  it { form.readonly?(:title).must_equal true }
+end

data/test/readable_test.rb

@@ -1,17 +1,17 @@
-require 'test_helper'
+require "test_helper"
 
 class ReadableTest < MiniTest::Spec
   Credentials = Struct.new(:password)
 
-  class PasswordForm < Reform::Form
+  class PasswordForm < TestForm
     property :password, readable: false
   end
 
-  let (:cred) { Credentials.new }
-  let (:form) { PasswordForm.new(cred) }
+  let(:cred) { Credentials.new }
+  let(:form) { PasswordForm.new(cred) }
 
   it {
-    form.password.must_equal nil # password not read.
+    assert_nil form.password # password not read.
 
     form.validate("password" => "123")
 
@@ -25,6 +25,6 @@ class ReadableTest < MiniTest::Spec
       hash = nested
     end
 
-    hash.must_equal("password"=> "123")
+    hash.must_equal("password" => "123")
   }
-end
+end

data/test/reform_new_api.rb

@@ -0,0 +1,204 @@
+require "test_helper"
+
+class ReformTest < Minitest::Spec
+  let(:comp) { OpenStruct.new(name: "Duran Duran", title: "Rio") }
+
+  let(:form) { SongForm.new(comp) }
+
+  class SongForm < TestForm
+    property :name
+    property :title
+
+    validation do
+      params { required(:name).filled }
+    end
+  end
+
+  describe "(new) form with empty models" do
+    let(:comp) { OpenStruct.new }
+
+    it "returns empty fields" do
+      assert_nil form.title
+      form.name.must_be_nil
+    end
+
+    describe "and submitted values" do
+      it "returns filled-out fields" do
+        form.validate("name" => "Duran Duran")
+
+        assert_nil form.title
+        form.name.must_equal "Duran Duran"
+      end
+    end
+  end
+
+  describe "(edit) form with existing models" do
+    it "returns filled-out fields" do
+      form.name.must_equal  "Duran Duran"
+      form.title.must_equal "Rio"
+    end
+  end
+
+  describe "#validate" do
+    let(:comp) { OpenStruct.new }
+
+    it "ignores unmapped fields in input" do
+      form.validate("name" => "Duran Duran", :genre => "80s")
+      assert_raises NoMethodError do
+        form.genre
+      end
+    end
+
+    it "returns true when valid" do
+      form.validate("name" => "Duran Duran").must_equal true
+    end
+
+    it "exposes input via property accessors" do
+      form.validate("name" => "Duran Duran")
+
+      form.name.must_equal "Duran Duran"
+    end
+
+    it "doesn't change model properties" do
+      form.validate("name" => "Duran Duran")
+
+      assert_nil comp.name # don't touch model, yet.
+    end
+
+    # TODO: test errors. test valid.
+    describe "invalid input" do
+      class ValidatingForm < TestForm
+        property :name
+        property :title
+
+        validation do
+          params do
+            required(:name).filled
+            required(:title).filled
+          end
+        end
+      end
+      let(:form) { ValidatingForm.new(comp) }
+
+      it "returns false when invalid" do
+        form.validate({}).must_equal false
+      end
+
+      it "populates errors" do
+        form.validate({})
+        form.errors.messages.must_equal(name: ["must be filled"], title: ["must be filled"])
+      end
+    end
+  end
+
+  describe "#save" do
+    let(:comp) { OpenStruct.new }
+    let(:form) { SongForm.new(comp) }
+
+    before { form.validate("name" => "Diesel Boy") }
+
+    it "xxpushes data to models" do
+      form.save
+
+      comp.name.must_equal "Diesel Boy"
+      assert_nil comp.title
+    end
+
+    describe "#save with block" do
+      it do
+        hash = {}
+
+        form.save do |map|
+          hash = map
+        end
+
+        hash.must_equal("name" => "Diesel Boy", "title" => nil)
+      end
+    end
+  end
+
+  describe "#model" do
+    it { form.model.must_equal comp }
+  end
+
+  describe "inheritance" do
+    class HitForm < SongForm
+      property :position
+      validation do
+        params { required(:position).filled }
+      end
+    end
+
+    let(:form) { HitForm.new(OpenStruct.new()) }
+    it do
+      form.validate("title" => "The Body")
+      form.title.must_equal "The Body"
+      assert_nil form.position
+      form.errors.messages.must_equal(name: ["must be filled"], position: ["must be filled"])
+    end
+  end
+end
+
+class OverridingAccessorsTest < BaseTest
+  class SongForm < TestForm
+    property :title
+
+    def title=(v) # used in #validate.
+      super v * 2
+    end
+
+    def title # used in #sync.
+      super.downcase
+    end
+  end
+
+  let(:song) { Song.new("Pray") }
+  subject { SongForm.new(song) }
+
+  # override reader for presentation.
+  it { subject.title.must_equal "pray" }
+
+  describe "#save" do
+    before { subject.validate("title" => "Hey Little World") }
+
+    # reader always used
+    it { subject.title.must_equal "hey little worldhey little world" }
+
+    # the reader is not used when saving/syncing.
+    it do
+      subject.save do |hash|
+        hash["title"].must_equal "Hey Little WorldHey Little World"
+      end
+    end
+
+    # no reader or writer used when saving/syncing.
+    it do
+      song.extend(Saveable)
+      subject.save
+      song.title.must_equal "Hey Little WorldHey Little World"
+    end
+  end
+end
+
+class MethodInFormTest < MiniTest::Spec
+  class AlbumForm < TestForm
+    property :title
+
+    def title
+      "The Suffer And The Witness"
+    end
+
+    property :hit do
+      property :title
+
+      def title
+        "Drones"
+      end
+    end
+  end
+
+  # methods can be used instead of created accessors.
+  subject { AlbumForm.new(OpenStruct.new(hit: OpenStruct.new)) }
+  it { subject.title.must_equal "The Suffer And The Witness" }
+  it { subject.hit.title.must_equal "Drones" }
+end