reform 1.0.4 → 1.1.0

data/test/form_composition_test.rb

@@ -1,28 +1,32 @@
 require 'test_helper'
 
 class FormCompositionTest < MiniTest::Spec
-  Song      = Struct.new(:id, :title)
+  Song      = Struct.new(:id, :title, :band)
   Requester = Struct.new(:id, :name, :requester)
+  Band      = Struct.new(:title)
 
   class RequestForm < Reform::Form
     include Composition
 
-    # TODO: remove skip_accessors in 1.1.
-    property  :name,          :on =>  :requester, :skip_accessors => true
-    property  :requester_id,  :on => :requester, :as => :id, :skip_accessors => true
+    property  :name,          :on =>  :requester
+    property  :requester_id,  :on => :requester, :as => :id
     properties [:title, :id], :on => :song
     # property  :channel # FIXME: what about the "main model"?
     property :channel, :empty => true, :on => :song
-    property :requester,      :on => :requester, :skip_accessors => true
+    property :requester,      :on => :requester
     property :captcha,        :on => :song, :empty => true
 
     validates :name, :title, :channel, :presence => true
-  end
 
-  let (:form)   { RequestForm.new(:song => song, :requester => requester) }
-  let (:song)   { Song.new(1, "Rio") }
-  let (:requester) { Requester.new(2, "Duran Duran", "MCP") }
+    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 }
@@ -33,11 +37,6 @@ class FormCompositionTest < MiniTest::Spec
   it { form.requester.must_equal "MCP" } # same name as composed model.
   it { form.captcha.must_equal nil }
 
-  # [DEPRECATED] # TODO: remove in 1.2.
-  # delegation form -> composed models (e.g. when saving this can be handy)
-  it { form.song.must_equal song }
-
-
   # #model just returns <Composition>.
   it { form.model.must_be_kind_of Reform::Composition }
 
@@ -51,12 +50,13 @@ class FormCompositionTest < MiniTest::Spec
   end
 
   describe "#save" do
-    it "provides data block argument" do
+    # #save with {}
+    it do
       hash = {}
 
-      form.save do |data, map|
-        hash[:name]   = data.name
-        hash[:title]  = data.title
+      form.save do |map|
+        hash[:name]   = form.name
+        hash[:title]  = form.title
       end
 
       hash.must_equal({:name=>"Duran Duran", :title=>"Rio"})
@@ -65,21 +65,23 @@ class FormCompositionTest < MiniTest::Spec
     it "provides nested symbolized hash as second block argument" do
       form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "channel" => "JJJ", "captcha" => "wonderful")
 
-      hash = {}
+      hash = nil
 
-      form.save do |data, map|
+      form.save do |map|
         hash = map
       end
 
       hash.must_equal({
-        :song=>{:title=>"Greyhound", :id=>1, :channel => "JJJ", :captcha=>"wonderful"},
-        :requester=>{:name=>"Frenzal Rhomb", :id=>2, :requester => "MCP"}}
+        :song=>{:title=>"Greyhound", :id=>1, :channel => "JJJ", :captcha=>"wonderful", :band=>{"title"=>"Duran^2"}},
+        :requester=>{:name=>"Frenzal Rhomb", :id=>2, :requester => "MCP"}
+        }
       )
     end
 
     it "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.
@@ -90,6 +92,32 @@ class FormCompositionTest < MiniTest::Spec
       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
   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/inherit_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+require 'representable/json'
+
+class InheritTest < BaseTest
+  class CompilationForm < AlbumForm
+
+    property :hit, :inherit => true do
+      property :rating
+      validates :title, :rating, :presence => true
+    end
+
+    # puts representer_class.representable_attrs.
+    #   get(:hit)[:extend].evaluate(nil).new(OpenStruct.new).rating
+  end
+
+  let (:album) { Album.new(nil, OpenStruct.new(:hit => OpenStruct.new()) ) }
+  subject { CompilationForm.new(album) }
+
+
+  # valid.
+  it {
+    subject.validate("hit" => {"title" => "LA Drone", "rating" => 10})
+    subject.hit.title.must_equal "LA Drone"
+    subject.hit.rating.must_equal 10
+    subject.errors.messages.must_equal({})
+  }
+
+  it do
+    subject.validate({})
+    subject.hit.title.must_equal nil
+    subject.hit.rating.must_equal nil
+    subject.errors.messages.must_equal({:"hit.title"=>["can't be blank"], :"hit.rating"=>["can't be blank"]})
+  end
+end
+
+
+class ModuleInclusionTest < MiniTest::Spec
+  module BandPropertyForm
+    include Reform::Form::Module
+
+    property :band do
+      property :title
+
+      validates :title, :presence => true
+
+      def id # gets mixed into Form, too.
+        2
+      end
+    end
+
+    def id # gets mixed into Form, too.
+      1
+    end
+
+    validates :band, :presence => true
+  end
+
+
+  class SongForm < Reform::Form
+    property :title
+
+    include BandPropertyForm
+  end
+
+  let (:song) { OpenStruct.new(:band => OpenStruct.new(:title => "Time Again")) }
+
+  # nested form from module is present and creates accessor.
+  it { SongForm.new(song).band.title.must_equal "Time Again" }
+
+  # methods from module get included.
+  it { SongForm.new(song).id.must_equal 1 }
+  it { SongForm.new(song).band.id.must_equal 2 }
+
+  it do
+     form = SongForm.new(OpenStruct.new())
+     form.validate({})
+     form.errors.messages.must_equal({:band=>["can't be blank"]})
+  end
+end

data/test/model_validations_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+class ModelValidationsTest < MiniTest::Spec
+
+  class Album
+    include ActiveModel::Validations
+    attr_accessor :title, :artist, :other_attribute
+
+    validates :title, :artist, presence: true
+    validates :other_attribute, presence: true
+  end
+
+  class AlbumRating
+    include ActiveModel::Validations
+
+    attr_accessor :rating
+
+    validates :rating, numericality: { greater_than_or_equal_to: 0 }
+
+  end
+
+  class AlbumForm < Reform::Form
+    extend ActiveModel::ModelValidations
+
+    property :title
+    property :artist_name, as: :artist
+    copy_validations_from Album
+  end
+
+  class CompositeForm < Reform::Form
+    include Composition
+    extend ActiveModel::ModelValidations
+
+    model :album
+
+    property :title, on: :album
+    property :artist_name, as: :artist, on: :album
+    property :rating, on: :album_rating
+
+    copy_validations_from album: Album, album_rating: AlbumRating
+  end
+
+  let(:album) { Album.new }
+
+  describe 'non-composite form' do
+
+    let(:album_form) { AlbumForm.new(album) }
+
+    it 'is not valid when title is not present' do
+      album_form.validate(artist_name: 'test', title: nil).must_equal false
+    end
+
+    it 'is not valid when artist_name is not present' do
+      album_form.validate(artist_name: nil, title: 'test').must_equal false
+    end
+
+    it 'is valid when title and artist_name is present' do
+      album_form.validate(artist_name: 'test', title: 'test').must_equal true
+    end
+
+  end
+
+  describe 'composite form' do
+
+    let(:album_rating) { AlbumRating.new }
+    let(:composite_form) { CompositeForm.new(album: album, album_rating: album_rating) }
+
+    it 'is valid when all attributes are correct' do
+      composite_form.validate(artist_name: 'test', title: 'test', rating: 1).must_equal true
+    end
+
+    it 'is invalid when rating is below 0' do
+      composite_form.validate(artist_name: 'test', title: 'test', rating: -1).must_equal false
+    end
+
+    it 'is invalid when artist_name is missing' do
+      composite_form.validate(artist_name: nil, title: 'test', rating: 1).must_equal false
+    end
+
+  end
+
+end

data/test/nested_form_test.rb

@@ -39,7 +39,7 @@ class NestedFormTest < MiniTest::Spec
 
   it "responds to #save" do
     hsh = nil
-    form.save do |f, nested|
+    form.save do |nested|
       hsh = nested
     end
     hsh.must_equal({"hit"=>{"title"=>"Downtown"}, "title" => "Blackhawks Over Los Angeles", "songs"=>[{"title"=>"Calling"}]})
@@ -103,21 +103,10 @@ class NestedFormTest < MiniTest::Spec
       data.must_equal(:title=>"Second Heat", :hit_title => "Sacrifice", :first_title => "Scarified")
     end
 
-    it "passes form instances in first argument" do
-      frm = nil
-
-      form.save { |f, hsh| frm = f }
-
-      frm.must_equal form
-      frm.title.must_be_kind_of String
-      frm.hit.must_be_kind_of Reform::Form
-      frm.songs.first.must_be_kind_of Reform::Form
-    end
-
     it "returns nested hash with indifferent access" do
       nested = nil
 
-      form.save do |hash, nested_hash|
+      form.save do |nested_hash|
         nested = nested_hash
       end
 

data/test/reform_test.rb

@@ -204,7 +204,7 @@ class ReformTest < ReformSpec
     end
 
     describe "#save with block" do
-      it "provides data block argument" do
+      it "Deprecated: provides data block argument" do # TODO: remove in 1.1.
         hash = {}
 
         form.save do |data, map|
@@ -215,7 +215,7 @@ class ReformTest < ReformSpec
         hash.must_equal({:name=>"Diesel Boy", :title=>nil})
       end
 
-      it "provides nested symbolized hash as second block argument" do
+      it "Deprecated: provides nested symbolized hash as second block argument" do # TODO: remove in 1.1.
         hash = {}
 
         form.save do |data, map|
@@ -224,6 +224,16 @@ class ReformTest < ReformSpec
 
         hash.must_equal({"name"=>"Diesel Boy"})
       end
+
+      it do
+        hash = {}
+
+        form.save do |map|
+          hash = map
+        end
+
+        hash.must_equal({"name"=>"Diesel Boy"})
+      end
     end
   end
 
@@ -239,7 +249,7 @@ class ReformTest < ReformSpec
       validates :position, :presence => true
     end
 
-    let (:form) { HitForm.new(OpenStruct.new) }
+    let (:form) { HitForm.new(OpenStruct.new()) }
     it do
       form.validate({"title" => "The Body"})
       form.title.must_equal "The Body"
@@ -247,8 +257,73 @@ 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)
 
@@ -270,7 +345,7 @@ class EmptyAttributesTest < MiniTest::Spec
     cred.password.must_equal "123"
 
     hash = {}
-    form.save do |f, nested|
+    form.save do |nested|
       hash = nested
     end
 
@@ -298,7 +373,7 @@ class ReadonlyAttributesTest < MiniTest::Spec
     loc.country.must_equal "Australia" # the writer wasn't called.
 
     hash = {}
-    form.save do |f, nested|
+    form.save do |nested|
       hash = nested
     end
 
@@ -335,7 +410,7 @@ class OverridingAccessorsTest < BaseTest
 
     # the reader is not used when saving/syncing.
     it do
-      subject.save do |f, hash|
+      subject.save do |hash|
         hash["title"].must_equal "Hey Little WorldHey Little World"
       end
     end
@@ -347,4 +422,28 @@ class OverridingAccessorsTest < BaseTest
       song.title.must_equal "Hey Little WorldHey Little World"
     end
   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