reform 2.2.4

data/test/coercion_test.rb

@@ -0,0 +1,66 @@
+require "test_helper"
+require "reform/form/coercion"
+
+class CoercionTest < BaseTest
+  class Irreversible
+    def self.call(value)
+      value*2
+    end
+  end
+
+  class Form < Reform::Form
+    feature Coercion
+
+    property :released_at, type: Types::Form::DateTime
+
+    property :hit do
+      property :length, type: Types::Form::Int
+      property :good,   type: Types::Form::Bool
+    end
+
+    property :band do
+      property :label do
+        property :value, type: Irreversible
+      end
+    end
+  end
+
+  subject do
+    Form.new(album)
+  end
+
+  let (:album) {
+    OpenStruct.new(
+      :released_at => "31/03/1981",
+      :hit         => OpenStruct.new(:length => "312"),
+      :band        => Band.new(OpenStruct.new(:value => "9999.99"))
+    )
+  }
+
+  # 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) {
+    {
+      :released_at => "30/03/1981",
+      :hit         => {:length => "312"},
+      :band        => {:label => {:value => "9999.99"}}
+    }
+  }
+
+
+  # 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.
+  end
+
+  # save
+end

data/test/composition_test.rb

@@ -0,0 +1,149 @@
+require 'test_helper'
+
+class FormCompositionTest < MiniTest::Spec
+  Song      = Struct.new(:id, :title, :band)
+  Requester = Struct.new(:id, :name, :requester)
+  Band      = Struct.new(:title)
+
+  class RequestForm < Reform::Form
+    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
+      key(:name).required
+      key(:name).required
+      key(:title).required
+    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 { form.channel.must_equal nil }
+  it { form.requester.must_equal "MCP" } # same name as composed model.
+  it { form.captcha.must_equal nil }
+
+  # #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 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 < Reform::Form
+    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 do |hash| hash.must_equal({:library=>{"books"=>[{"id"=>1, "name"=>"My book"}]}}) end }
+end

data/test/contract_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+class ContractTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :duration, :songs, :artist)
+  Artist = Struct.new(:name)
+
+  class ArtistForm < Reform::Form
+    property :name
+  end
+
+  class AlbumForm < Reform::Contract
+    property :name
+
+    properties :duration
+    properties :year, :style, readable: false
+
+    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, form: ArtistForm
+  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", 123, [song, song_with_composer], artist) }
+
+  let (:form) { AlbumForm.new(album) }
+
+  # accept `property form: SongForm`.
+  it do
+    form.artist.must_be_instance_of ArtistForm
+  end
+
+  describe ".properties" do
+    it "defines a property when called with one argument" do
+      form.must_respond_to :duration
+    end
+
+    it "defines several properties when called with multiple arguments" do
+      form.must_respond_to :year
+      form.must_respond_to :style
+    end
+
+    it "passes options to each property when options are provided" do
+      readable = AlbumForm.new(album).options_for(:style)[:readable]
+      readable.must_equal false
+    end
+
+    it "returns the list of defined properties" do
+      returned_value = AlbumForm.properties(:hello, :world, virtual: true)
+      returned_value.must_equal [:hello, :world]
+    end
+  end
+
+  describe "#options_for" do
+    it { AlbumForm.options_for(:name).extend(Declarative::Inspect).inspect.must_equal "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
+    it { AlbumForm.new(album).options_for(:name).extend(Declarative::Inspect).inspect.must_equal "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
+  end
+end

data/test/default_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+
+class DefaultTest < Minitest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
+
+  class AlbumForm < Reform::Form
+    property :name, default: "Wrong"
+
+    collection :songs do
+      property :title, default: "It's Catching Up"
+    end
+  end
+
+  it do
+    form = AlbumForm.new(Album.new(nil, [Song.new]))
+
+    form.name.must_equal "Wrong"
+    form.songs[0].title.must_equal "It's Catching Up"
+  end
+end

data/test/deprecation_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+
+
+class DeprecationRemoveMePopulatorTest < MiniTest::Spec
+  Album = Struct.new(:songs)
+  Song  = Struct.new(:title)
+
+
+  class AlbumForm < Reform::Form
+    collection :songs, populator: ->(fragment, collection, index, *) { return Representable::Pipeline::Stop if fragment[:title]=="Good"
+      songs[index]
+              } do
+      property :title
+    end
+  end
+
+  it do
+    form = AlbumForm.new(Album.new([Song.new, Song.new]))
+    hash = {songs: [{title: "Good"}, {title: "Bad"}]}
+
+    form.validate(hash)
+
+    form.songs.size.must_equal 2
+    form.songs[0].title.must_equal nil
+    form.songs[1].title.must_equal "Bad"
+  end
+end

data/test/deserialize_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+require "representable/json"
+
+class DeserializeTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:title, :artist)
+  Artist = Struct.new(:name, :callname)
+
+  class JsonAlbumForm < Reform::Form
+    module Json
+      def deserialize(params)
+        deserializer.new(self).
+        # extend(Representable::Debug).
+          from_json(params)
+      end
+
+      def deserializer
+        Disposable::Rescheme.from(self.class,
+          include:          [Representable::JSON],
+          superclass:       Representable::Decorator,
+          definitions_from: lambda { |inline| inline.definitions },
+          options_from:     :deserializer,
+          exclude_options:  [:populator]
+        )
+      end
+    end
+    include Json
+
+
+    property :title
+    property :artist, populate_if_empty: Artist do
+      property :name
+    end
+  end
+
+
+  let (:artist) { Artist.new("A-ha") }
+  it do
+    artist_id = artist.object_id
+
+    form = JsonAlbumForm.new(Album.new("Best Of", artist))
+    json = MultiJson.dump({title: "Apocalypse Soon", artist: {name: "Mute"}})
+
+    form.validate(json)
+
+    form.title.must_equal "Apocalypse Soon"
+    form.artist.name.must_equal "Mute"
+    form.artist.model.object_id.must_equal artist_id
+  end
+
+  describe "infering the deserializer from another form should NOT copy its populators" do
+    class CompilationForm < Reform::Form
+      property :artist, populator: ->(options) { self.artist = Artist.new(nil, options[:fragment].to_s) } do
+        property :name
+      end
+
+      def deserializer
+        super(JsonAlbumForm, include: [Representable::Hash])
+      end
+    end
+
+    # also tests the Form#deserializer API. # FIXME.
+    it "uses deserializer inferred from JsonAlbumForm but deserializes/populates to CompilationForm" do
+      form = CompilationForm.new(Album.new)
+      form.validate("artist"=> {"name" => "Horowitz"}) # the deserializer doesn't know symbols.
+      form.sync
+      form.artist.model.must_equal Artist.new("Horowitz", %{{"name"=>"Horowitz"}})
+    end
+  end
+end
+
+
+class ValidateWithBlockTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:title, :artist)
+  Artist = Struct.new(:name)
+
+  class AlbumForm < Reform::Form
+    property :title
+    property :artist, populate_if_empty: Artist do
+      property :name
+    end
+  end
+
+  it do
+    album = Album.new
+    form  = AlbumForm.new(album)
+    json  = MultiJson.dump({title: "Apocalypse Soon", artist: {name: "Mute"}})
+
+    deserializer = Disposable::Rescheme.from(AlbumForm,
+      include:          [Representable::JSON],
+      superclass:       Representable::Decorator,
+      definitions_from: lambda { |inline| inline.definitions },
+      options_from:     :deserializer
+    )
+
+    form.validate(json) do |params|
+      deserializer.new(form).from_json(params)
+    end.must_equal true # with block must return result, too.
+
+    form.title.must_equal "Apocalypse Soon"
+    form.artist.name.must_equal "Mute"
+  end
+end