reform 2.2.4

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/read_only_test.rb

@@ -0,0 +1,3 @@
+require 'test_helper'
+
+

data/test/readable_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class ReadableTest < MiniTest::Spec
+  Credentials = Struct.new(:password)
+
+  class PasswordForm < Reform::Form
+    property :password, readable: false
+  end
+
+  let (:cred) { Credentials.new }
+  let (:form) { PasswordForm.new(cred) }
+
+  it {
+    form.password.must_equal nil # password not read.
+
+    form.validate("password" => "123")
+
+    form.password.must_equal "123"
+
+    form.sync
+    cred.password.must_equal "123" # password written.
+
+    hash = {}
+    form.save do |nested|
+      hash = nested
+    end
+
+    hash.must_equal("password"=> "123")
+  }
+end

data/test/readonly_test.rb

@@ -0,0 +1,14 @@
+require "test_helper"
+
+class ReadonlyTest < MiniTest::Spec
+  class SongForm < Reform::Form
+    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/reform_test.rb

@@ -0,0 +1,223 @@
+require 'test_helper'
+
+# TODO: this test should be removed.
+class ReformTest < Minitest::Spec
+  let (:comp) { OpenStruct.new(:name => "Duran Duran", :title => "Rio") }
+
+  let (:form) { SongForm.new(comp) }
+
+  class SongForm < Reform::Form
+    property :name
+    property :title
+
+    validation do
+      key(:name).required
+    end
+  end
+
+  describe "(new) form with empty models" do
+    let (:comp) { OpenStruct.new }
+
+    it "returns empty fields" do
+      form.title.must_equal nil
+      form.name.must_equal  nil
+    end
+
+    describe "and submitted values" do
+      it "returns filled-out fields" do
+        form.validate("name" => "Duran Duran")
+
+        form.title.must_equal nil
+        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")
+
+      comp.name.must_equal nil # don't touch model, yet.
+    end
+
+    # TODO: test errors. test valid.
+    describe "invalid input" do
+      class ValidatingForm < Reform::Form
+        property :name
+        property :title
+
+        validation do
+          key(:name).required
+          key(:title).required
+        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=>["is missing"], :title=>["is missing"]})
+      end
+    end
+  end
+
+  # FIXME: add this test to reform-rails.
+  describe "#errors" do
+    before { form.validate({})}
+
+    it { form.errors.must_be_kind_of Reform::Contract::Errors }
+
+    it { form.errors.messages.must_equal({}) }
+
+    it do
+      form.validate({"name"=>""})
+      form.errors.messages.must_equal({:name=>["must be filled"]})
+    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"
+      comp.title.must_equal nil
+    end
+
+    describe "#save with block" do
+      it do
+        hash = {}
+
+        form.save do |map|
+          hash = map
+        end
+
+        hash.must_equal({"name"=>"Diesel Boy"})
+      end
+    end
+  end
+
+
+  describe "#model" do
+    it { form.model.must_equal comp }
+  end
+
+
+  describe "inheritance" do
+    class HitForm < SongForm
+      property :position
+      validation do
+        key(:position).required
+      end
+    end
+
+    let (:form) { HitForm.new(OpenStruct.new()) }
+    it do
+      form.validate({"title" => "The Body"})
+      form.title.must_equal "The Body"
+      form.position.must_equal nil
+      form.errors.messages.must_equal({:name=>["is missing"], :position=>["is missing"]})
+    end
+  end
+end
+
+
+class OverridingAccessorsTest < BaseTest
+  class SongForm < Reform::Form
+    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 < Reform::Form
+    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

data/test/save_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+class SaveTest < BaseTest
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
+
+  class AlbumForm < Reform::Form
+    property :name
+    validation do
+      key(:name).required
+    end
+
+    collection :songs do
+      property :title
+      validation do
+        key(:title).required
+      end
+
+      property :composer do
+        property :name
+        validation do
+          key(:name).required
+        end
+      end
+    end
+
+    property :artist, save: false do
+      property :name
+    end
+  end
+
+  module Saveable
+    def save
+      @saved = true
+    end
+
+    def saved?
+      @saved
+    end
+  end
+
+
+  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
+    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 SongForm < Reform::Form
+#     property :title#, save: false
+#     property :length, virtual: true
+#   end
+
+#   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}" })
+
+#     song.title.must_equal "A Poor Man's Memory"
+#     song.length.must_equal nil
+#     song.id.must_equal "10: 120"
+#   end
+# end