reform 1.1.1 → 1.2.0.beta1

data/test/model_reflections_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+# Reform::ModelReflections will be the interface between the form object and form builders like simple_form.
+class ModelReflectionTest < MiniTest::Spec
+  class SongForm < Reform::Form
+    include Reform::Form::ActiveRecord
+    include Reform::Form::ModelReflections
+
+    model :song
+
+    property :title
+    property :artist do
+      property :name
+    end
+  end
+
+  module ColumnForAttribute
+    def column_for_attribute(*args)
+        "#{self.class}: #{args.inspect}"
+    end
+  end
+
+  describe "#column_for_attribute" do
+    let (:artist) { Artist.new }
+    let (:song) { Song.new(artist: artist) }
+    let (:form) { SongForm.new(song) }
+
+    # delegate to model.
+    it do
+      song.extend(ColumnForAttribute)
+      artist.extend(ColumnForAttribute)
+
+      form.column_for_attribute(:title).must_equal "Song: [:title]"
+      form.artist.column_for_attribute(:name).must_equal "Artist: [:name]"
+    end
+  end
+
+
+  class SongWithArtistForm < Reform::Form
+    include Reform::Form::ActiveRecord
+    include Reform::Form::ModelReflections
+    include Reform::Form::Composition
+
+    model :artist
+
+    property :name, on: :artist
+    property :title, on: :song
+  end
+
+  describe "#column_for_attribute with composition" do
+    let (:artist) { Artist.new }
+    let (:song) { Song.new }
+    let (:form) { SongWithArtistForm.new(artist: artist, song: song) }
+
+    # delegates to respective model.
+    it do
+      song.extend(ColumnForAttribute)
+      artist.extend(ColumnForAttribute)
+
+
+      form.column_for_attribute(:name).must_equal "Artist: [:name]"
+      form.column_for_attribute(:title).must_equal "Song: [:title]"
+    end
+  end
+end

data/test/read_only_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class ReadonlyAttributesTest < MiniTest::Spec
+  Location = Struct.new(:country)
+
+  class LocationForm < Reform::Form
+    property :country, virtual: true # read_only: true
+  end
+
+  let (:loc) { Location.new("Australia") }
+  let (:form) { LocationForm.new(loc) }
+
+  it { form.country.must_equal "Australia" }
+  it do
+    form.validate("country" => "Germany") # this usually won't change when submitting.
+    form.country.must_equal "Germany"
+
+    form.sync
+    loc.country.must_equal "Australia" # the writer wasn't called.
+
+    hash = {}
+    form.save do |nested|
+      hash = nested
+    end
+
+    hash.must_equal("country"=> "Germany")
+  end
+end

data/test/reform_test.rb

@@ -1,56 +1,5 @@
 require 'test_helper'
 
-class RepresenterTest < MiniTest::Spec
-  class SongRepresenter < Reform::Representer
-    property :title
-    property :name
-  end
-
-  let (:rpr) { SongRepresenter.new(Object.new) }
-
-  describe "#fields" do
-    it "returns all properties as strings" do
-      rpr.fields.must_equal(["title", "name"])
-    end
-  end
-end
-
-class WithOptionsTest < MiniTest::Spec
-  subject { Reform::Representer::WithOptions::Options.new }
-
-  it { subject.must_equal({}) }
-  it { subject.exclude!([:id, :title]).must_equal(:exclude => [:id, :title])   }
-  it do
-    subject.exclude!([:id, :title])
-    subject.exclude!([:id, :name])
-    subject.must_equal(:exclude => [:id, :title, :id, :name])
-  end
-  it { subject.include!([:id, :title]).must_equal(:include => [:id, :title]) }
-end
-
-class FieldsTest < MiniTest::Spec
-  describe "#new" do
-    it "accepts list of properties" do
-      fields = Reform::Contract::Fields.new([:name, :title])
-      fields.name.must_equal  nil
-      fields.title.must_equal nil
-    end
-
-    it "accepts list of properties and values" do
-      fields = Reform::Contract::Fields.new(["name", "title"], "title" => "The Body")
-      fields.name.must_equal  nil
-      fields.title.must_equal "The Body"
-    end
-
-    it "processes value syms" do
-      skip "we don't need to test this as representer.to_hash always returns strings"
-      fields = Reform::Fields.new(["name", "title"], :title => "The Body")
-      fields.name.must_equal  nil
-      fields.title.must_equal "The Body"
-    end
-  end
-end
-
 class ReformTest < ReformSpec
   let (:comp) { OpenStruct.new(:name => "Duran Duran", :title => "Rio") }
 
@@ -74,8 +23,8 @@ class ReformTest < ReformSpec
     subject do
       opts = options
       Class.new(Reform::Form) do
-        properties [:name, :title], opts
-        properties [:created_at]
+        properties :name, :title, opts
+        properties :created_at
       end.new(comp)
     end
 
@@ -247,128 +196,6 @@ class ReformTest < ReformSpec
       form.errors.messages.must_equal({:name=>["can't be blank"], :position=>["can't be blank"]})
     end
   end
-
-  describe "#column_for_attribute" do
-    let (:model) { Artist.new }
-    let (:klass) do
-      require 'reform/active_record'
-
-      Class.new Reform::Form do
-        include Reform::Form::ActiveRecord
-
-        model :artist
-
-        property :name
-      end
-    end
-    let (:form) { klass.new(model) }
-
-    it 'should delegate to the model' do
-      Calls = []
-
-      def model.column_for_attribute(*args)
-        Calls << [:column_for_attribute, *args]
-      end
-
-      form.column_for_attribute(:name)
-      Calls.must_include [:column_for_attribute, :name]
-    end
-  end
-
-  describe "#column_for_attribute with composition" do
-    let (:artist_model) { Artist.new }
-    let (:song_model) { Song.new }
-    let (:form_klass) do
-      require 'reform/active_record'
-
-      Class.new Reform::Form do
-        include Reform::Form::ActiveRecord
-        include Reform::Form::Composition
-
-        model :artist
-
-        property :name, on: :artist
-        property :title, on: :song
-      end
-    end
-    let (:form) { form_klass.new(artist: artist_model, song: song_model) }
-
-    it 'should delegate to the model' do
-      ArtistCalls, SongCalls = [], []
-
-      def artist_model.column_for_attribute(*args)
-        ArtistCalls << [:column_for_attribute, *args]
-      end
-
-      def song_model.column_for_attribute(*args)
-        SongCalls << [:column_for_attribute, *args]
-      end
-
-      form.column_for_attribute(:name)
-      ArtistCalls.must_include [:column_for_attribute, :name]
-
-      form.column_for_attribute(:title)
-      SongCalls.must_include [:column_for_attribute, :title]
-    end
-  end
-end
-
-
-class EmptyAttributesTest < MiniTest::Spec
-  Credentials = Struct.new(:password)
-
-  class PasswordForm < Reform::Form
-    property :password
-    property :password_confirmation, :empty => true
-  end
-
-  let (:cred) { Credentials.new }
-  let (:form) { PasswordForm.new(cred) }
-
-  before { form.validate("password" => "123", "password_confirmation" => "321") }
-
-  it {
-    form.password.must_equal "123"
-    form.password_confirmation.must_equal "321"
-
-    form.sync
-    cred.password.must_equal "123"
-
-    hash = {}
-    form.save do |nested|
-      hash = nested
-    end
-
-    hash.must_equal("password"=> "123", "password_confirmation" => "321")
-  }
-end
-
-class ReadonlyAttributesTest < MiniTest::Spec
-  Location = Struct.new(:country)
-
-  class LocationForm < Reform::Form
-    property :country, :virtual => true # read_only: true
-  end
-
-  let (:loc) { Location.new("Australia") }
-  let (:form) { LocationForm.new(loc) }
-
-  it { form.country.must_equal "Australia" }
-  it do
-    form.validate("country" => "Germany") # this usually won't change when submitting.
-    form.country.must_equal "Germany"
-
-
-    form.sync
-    loc.country.must_equal "Australia" # the writer wasn't called.
-
-    hash = {}
-    form.save do |nested|
-      hash = nested
-    end
-
-    hash.must_equal("country"=> "Germany")
-  end
 end
 
 

data/test/representer_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class RepresenterOptionsTest < MiniTest::Spec
+  subject { Reform::Representer::Options[] }
+
+  # don't maintain empty excludes until fixed in representable.
+  it { subject.exclude!([]).must_equal({:exclude=>[]}) }
+  it { subject.include!([]).must_equal({:include=>[]}) }
+
+  it { subject.exclude!([:title, :id]).must_equal({exclude: [:title, :id]}) }
+  it { subject.include!([:title, :id]).must_equal({include: [:title, :id]}) }
+
+
+  module Representer
+    include Representable::Hash
+    property :title
+    property :genre
+    property :id
+  end
+
+  it "representable" do
+    song = OpenStruct.new(title: "Title", genre: "Punk", id: 1)
+    puts Representer.prepare(song).to_hash(include: [:genre, :id], exclude: [:id]).inspect
+  end
+end
+
+
+class RepresenterTest < MiniTest::Spec
+  class SongRepresenter < Reform::Representer
+    property :title
+    property :name
+    property :genre
+  end
+
+  subject { SongRepresenter.new(Object.new) }
+
+  describe "#fields" do
+    it "returns all properties as strings" do
+      SongRepresenter.fields.must_equal(["title", "name", "genre"])
+    end
+
+    # allows block.
+    it do
+      SongRepresenter.fields { |dfn| dfn.name =~ /n/ }.must_equal ["name", "genre"]
+    end
+  end
+end

data/test/save_test.rb

@@ -1,6 +1,30 @@
 require 'test_helper'
 
 class SaveTest < BaseTest
+  class AlbumForm < Reform::Form
+    property :title
+
+    property :hit do
+      property :title
+      validates :title, :presence => true
+    end
+
+    collection :songs do
+      property :title
+      validates :title, :presence => true
+    end
+
+    property :band do # yepp, people do crazy stuff like that.
+      property :label do
+        property :name
+        validates :name, :presence => true
+      end
+      # TODO: make band a required object.
+    end
+
+    validates :title, :presence => true
+  end
+
   let (:params) {
     {
       "title" => "Best Of",
@@ -17,7 +41,7 @@ class SaveTest < BaseTest
   let (:band) { Band.new(label) }
   let (:label) { Label.new }
 
-  subject { ErrorsTest::AlbumForm.new(album) }
+  subject { AlbumForm.new(album) }
 
   before do
     [album, hit, song1, song2, band, label].each { |mdl| mdl.extend(Saveable) }
@@ -86,4 +110,30 @@ class SaveTest < BaseTest
     album.instance_eval { def save; false; end }
     subject.save.must_equal false
   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

data/test/scalar_test.rb

@@ -163,23 +163,5 @@ class SelfNestedTest < BaseTest
     form.validate({}).must_equal true
   end
 
-
-  it do
-    form = StringForm.new(AlbumCover.new(nil))
-    form.validate({"image"=>""}).must_equal true
-  end
-
-
-
-  # TODO: move to validate_test.
-  # property :rejection_reason, scalar: true, virtual: true, empty: true do # optional parameter
-  #         validates length: {minimum: 5}, if: lambda { model.present? and avatar_moderation == "2" } # IF present, at least 5 characters.
-  #       end
-  class BlaForm < Reform::Form
-    property :image# creates "empty" form
-    validates :image, :length => {:minimum => 10}, if: lambda { image and image != "" }
-  end
-
-  it { BlaForm.new(AlbumCover.new(nil)).validate({"image"=>""}).must_equal true }
   # DISCUSS: when AlbumCover.new("Hello").validate({}), does that fail?
 end

data/test/skip_if_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+class SkipIfTest < BaseTest
+
+  class AlbumForm < Reform::Form
+    property :title
+
+    property :hit, skip_if: lambda { |fragment, *| fragment["title"].blank? } do
+      property :title
+      validates :title, presence: true
+    end
+
+    collection :songs, skip_if: lambda { |fragment, *| fragment["title"].nil? },
+      populate_if_empty: BaseTest::Song do
+      property :title
+    end
+  end
+
+
+  let (:hit) { Song.new }
+  let (:album) { Album.new(nil, hit, [], nil) }
+
+  # deserializes when present.
+  it do
+    form = AlbumForm.new(album)
+    form.validate("hit" => {"title" => "Altar Of Sacrifice"}).must_equal true
+    form.hit.title.must_equal "Altar Of Sacrifice"
+  end
+
+  # skips deserialization when not present.
+  it do
+    form = AlbumForm.new(Album.new)
+    form.validate("hit" => {"title" => ""}).must_equal true
+    form.hit.must_equal nil # hit hasn't been deserialised.
+  end
+
+  # skips deserialization when not present.
+  it do
+    form = AlbumForm.new(Album.new(nil, nil, []))
+    form.validate("songs" => [{"title" => "Waste Of Breath"}, {"title" => nil}]).must_equal true
+    form.songs.size.must_equal 1
+    form.songs[0].title.must_equal "Waste Of Breath"
+  end
+end
+
+class SkipIfAllBlankTest < BaseTest
+  # skip_if: :all_blank"
+  class AlbumForm < Reform::Form
+    collection :songs, skip_if: :all_blank, populate_if_empty: BaseTest::Song do
+      property :title
+      property :length
+    end
+  end
+
+  # create only one object.
+  it do
+    form = AlbumForm.new(OpenStruct.new(songs: []))
+    form.validate("songs" => [{"title"=>"Apathy"}, {"title"=>"", "length" => ""}]).must_equal true
+    form.songs.size.must_equal 1
+    form.songs[0].title.must_equal "Apathy"
+  end
+end