reform 0.2.7 → 1.0.0

data/test/feature_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class FeatureInheritanceTest < BaseTest
+  class AlbumForm < Reform::Form
+    # include Reform::Form::ActiveModel
+    # include Coercion
+    # include MultiParameterAttributes
+
+    property :band do
+      property :label do
+      end
+    end
+  end
+
+  subject { AlbumForm.new(Album.new(nil, nil, nil, Band.new(Label.new))) }
+
+  # it { subject.class.include?(Reform::Form::ActiveModel) }
+  # it { subject.class.include?(Reform::Form::Coercion) }
+  # it { subject.is_a?(Reform::Form::MultiParameterAttributes) }
+
+  # it { subject.band.class.include?(Reform::Form::ActiveModel) }
+  # it { subject.band.is_a?(Reform::Form::Coercion) }
+  # it { subject.band.is_a?(Reform::Form::MultiParameterAttributes) }
+
+  # it { subject.band.label.is_a?(Reform::Form::ActiveModel) }
+  # it { subject.band.label.is_a?(Reform::Form::Coercion) }
+  # it { subject.band.label.is_a?(Reform::Form::MultiParameterAttributes) }
+end

data/test/form_builder_test.rb

@@ -0,0 +1,105 @@
+require 'test_helper'
+
+class FormBuilderCompatTest < BaseTest
+  let (:form_class) {
+    Class.new(Reform::Form) do
+      include Reform::Form::ActiveModel::FormBuilderMethods
+
+      property :artist do
+        property :name
+        validates :name, :presence => true
+      end
+
+      collection :songs do
+        property :title
+        property :release_date
+        validates :title, :presence => true
+      end
+
+      class LabelForm < Reform::Form
+        property :name
+      end
+
+      property :label, :form => LabelForm
+
+      property :band do
+        property :label do
+          property :name
+        end
+      end
+    end
+  }
+
+  let (:song) { OpenStruct.new }
+  let (:form) { form_class.new(OpenStruct.new(
+    :artist => Artist.new(:name => "Propagandhi"),
+    :songs  => [song],
+    :label  => OpenStruct.new,
+
+    :band => Band.new(Label.new)
+    )) }
+
+  it "respects _attributes params hash" do
+    form.validate("artist_attributes" => {"name" => "Blink 182"},
+      "songs_attributes" => {"0" => {"title" => "Damnit"}},
+      "band_attributes"  => {"label_attributes" => {"name" => "Epitaph"}})
+
+    form.artist.name.must_equal "Blink 182"
+    form.songs.first.title.must_equal "Damnit"
+    form.band.label.name.must_equal "Epitaph"
+  end
+
+  it "allows nested collection and property to be missing" do
+    form.validate({})
+
+    form.artist.name.must_equal "Propagandhi"
+
+    form.songs.size.must_equal 1
+    form.songs[0].model.must_equal song # this is a weird test.
+  end
+
+  it "defines _attributes= setter so Rails' FB works properly" do
+    form.must_respond_to("artist_attributes=")
+    form.must_respond_to("songs_attributes=")
+    form.must_respond_to("label_attributes=")
+  end
+
+  describe "deconstructed date parameters" do
+    let(:form_attributes) do
+      {
+        "artist_attributes" => {"name" => "Blink 182"},
+        "songs_attributes" => {"0" => {"title" => "Damnit", "release_date(1i)" => release_year,
+          "release_date(2i)" => release_month, "release_date(3i)" => release_day}}
+      }
+    end
+    let(:release_year) { "1997" }
+    let(:release_month) { "9" }
+    let(:release_day) { "27" }
+
+    describe "with valid parameters" do
+      it "creates a date" do
+        form.validate(form_attributes)
+
+        form.songs.first.release_date.must_equal Date.new(1997, 9, 27)
+      end
+    end
+
+    %w(year month day).each do |date_attr|
+      describe "when the #{date_attr} is missing" do
+        let(:"release_#{date_attr}") { "" }
+
+        it "rejects the date" do
+          form.validate(form_attributes)
+
+          form.songs.first.release_date.must_be_nil
+        end
+      end
+    end
+  end
+
+  it "returns flat errors hash" do
+    form.validate("artist_attributes" => {"name" => ""},
+      "songs_attributes" => {"0" => {"title" => ""}})
+    form.errors.messages.must_equal(:"artist.name" => ["can't be blank"], :"songs.title" => ["can't be blank"])
+  end
+end

data/test/form_composition_test.rb

@@ -1,26 +1,36 @@
 require 'test_helper'
 
 class FormCompositionTest < MiniTest::Spec
-  class SongForm < Reform::Form
+  Song      = Struct.new(:id, :title)
+  Requester = Struct.new(:id, :name)
+
+  class RequestForm < Reform::Form
     include Composition
 
-    property  :title,           :on => :song
-    properties [:name, :genre], :on => :artist
+    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
 
-    validates :name, :title, :genre, :presence => true
+    validates :name, :title, :channel, :presence => true
   end
 
-  let (:form)   { SongForm.new(:song => song, :artist => artist) }
-  let (:song)   { OpenStruct.new(:title => "Rio") }
-  let (:artist) { OpenStruct.new(:name => "Duran Duran") }
+  let (:form)   { RequestForm.new(:song => song, :requester => requester) }
+  let (:song)   { Song.new(1, "Rio") }
+  let (:requester) { Requester.new(2, "Duran Duran") }
 
 
   # delegation form -> composition works
-  it { form.title.must_equal  "Rio" }
-  it { form.name.must_equal   "Duran Duran" }
+  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 }
+
   # delegation form -> composed models (e.g. when saving this can be handy)
   it { form.song.must_equal   song }
-  it { form.artist.must_equal artist }
+  it { form.requester.must_equal requester }
 
 
   it "creates Composition for you" do
@@ -40,21 +50,28 @@ class FormCompositionTest < MiniTest::Spec
     end
 
     it "provides nested symbolized hash as second block argument" do
+      form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "channel" => "JJJ")
+
       hash = {}
 
       form.save do |data, map|
         hash = map
       end
 
-      hash.must_equal({:song=>{:title=>"Rio"}, :artist=>{:name=>"Duran Duran"}})
+      hash.must_equal({:song=>{:title=>"Greyhound", :id=>1, :channel => "JJJ"}, :requester=>{:name=>"Frenzal Rhomb", :id=>2}})
     end
 
-    it "pushes data to models when no block passed" do
+    it "pushes data to models and calls #save when no block passed" do
+      song.extend(Saveable)
+      requester.extend(Saveable)
+
       form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb")
       form.save
 
-      artist.name.must_equal "Frenzal Rhomb"
+      requester.name.must_equal "Frenzal Rhomb"
+      requester.saved?.must_equal true
       song.title.must_equal "Greyhound"
+      song.saved?.must_equal true
     end
   end
 end

data/test/nested_form_test.rb

@@ -37,14 +37,18 @@ class NestedFormTest < MiniTest::Spec
   let (:songs) { [OpenStruct.new(:title => "Calling")] }
   let (:form)  { AlbumForm.new(album) }
 
-  it "responds to #to_hash" do
-    form.to_hash.must_equal({"hit"=>{"title"=>"Downtown"}, "title" => "Blackhawks Over Los Angeles", "songs"=>[{"title"=>"Calling"}]})
+  it "responds to #save" do
+    hsh = nil
+    form.save do |f, nested|
+      hsh = nested
+    end
+    hsh.must_equal({"hit"=>{"title"=>"Downtown"}, "title" => "Blackhawks Over Los Angeles", "songs"=>[{"title"=>"Calling"}]})
   end
 
 
   it "creates nested forms" do
     form.hit.must_be_kind_of Reform::Form
-    form.songs.must_be_kind_of Reform::Form::Forms
+    form.songs.must_be_kind_of Array
   end
 
   describe "#initialize" do
@@ -70,19 +74,7 @@ class NestedFormTest < MiniTest::Spec
       # end
     end
 
-    describe "with empty object and cardinality" do
-      subject { Class.new(Reform::Form) do
-        # collection :songs, :validates => {:length => {:minimum => 1}}
-        collection :songs, :cardinality => {:minimum => 1} do
-          property :title
-        end
-      end.new(OpenStruct.new) }
-
-      it "whatxxx" do
-        subject.validate({}).must_equal false
-        subject.errors.messages.must_equal(:"songs.size"=>["songs size is 0 but must be {:minimum=>1}"])
-      end
-    end
+
   end
 
 
@@ -194,14 +186,16 @@ class NestedFormTest < MiniTest::Spec
       form.hit.title.must_equal "Downtown"
     end
 
-    it { form.validate({"hit" => {"title" => ""}})
+    it ("xxx") {
+      form.validate({"hit" => {"title" => ""}})
+      form.hit.title.must_equal ""
       form.errors[:"hit.title"].must_equal(["can't be blank"])
     }
   end
 
   class UnitTest < self
     it "keeps Forms for form collection" do
-      form.send(:fields).songs.must_be_kind_of Reform::Form::Forms
+      form.send(:fields).songs.must_be_kind_of Array
     end
 
     describe "#validate" do

data/test/reform_test.rb

@@ -31,13 +31,13 @@ end
 class FieldsTest < MiniTest::Spec
   describe "#new" do
     it "accepts list of properties" do
-      fields = Reform::Fields.new([:name, :title])
+      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::Fields.new(["name", "title"], "title" => "The Body")
+      fields = Reform::Contract::Fields.new(["name", "title"], "title" => "The Body")
       fields.name.must_equal  nil
       fields.title.must_equal "The Body"
     end
@@ -58,11 +58,14 @@ class ReformTest < ReformSpec
 
 
   describe "::properties" do
-    it do
+    subject do
       Class.new(Reform::Form) do
         properties [:name, :title]
-      end.new(comp).to_hash.must_equal({"name"=>"Duran Duran", "title"=>"Rio"})
+      end.new(comp)
     end
+
+    it { subject.name.must_equal "Duran Duran" }
+    it { subject.title.must_equal "Rio" }
   end
 
   class SongForm < Reform::Form
@@ -163,6 +166,8 @@ class ReformTest < ReformSpec
   end
 
   describe "#errors" do
+    before { form.validate({})}
+
     it { form.errors.must_be_kind_of Reform::Form::Errors }
 
     it { form.errors.messages.must_equal({}) }
@@ -252,7 +257,7 @@ class EmptyAttributesTest < MiniTest::Spec
     form.password.must_equal "123"
     form.password_confirmation.must_equal "321"
 
-    form.save
+    form.sync
     cred.password.must_equal "123"
 
     hash = {}
@@ -280,7 +285,7 @@ class ReadonlyAttributesTest < MiniTest::Spec
     form.country.must_equal "Germany"
 
 
-    form.save
+    form.sync
     loc.country.must_equal "Australia" # the writer wasn't called.
 
     hash = {}

data/test/save_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+class SaveTest < BaseTest
+  let (:params) {
+    {
+      "title" => "Best Of",
+      "hit"   => {"title" => "Roxanne"},
+      "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"}],
+      :band  => {:label => {:name => "Polydor"}}
+    }
+  }
+
+  let (:album) { Album.new(nil, hit, [song1, song2], band) }
+  let (:hit) { Song.new }
+  let (:song1) { Song.new }
+  let (:song2) { Song.new }
+  let (:band) { Band.new(label) }
+  let (:label) { Label.new }
+
+  subject { ErrorsTest::AlbumForm.new(album) }
+
+  before do
+    [album, hit, song1, song2, band, label].each { |mdl| mdl.extend(Saveable) }
+
+    subject.validate(params)
+    subject.save
+  end
+
+  # synced?
+  it { album.title.must_equal "Best Of" }
+  it { hit.title.must_equal "Roxanne" }
+  it { song1.title.must_equal "Fallout" }
+  it { song2.title.must_equal "Roxanne" }
+  it { label.name.must_equal "Polydor" }
+
+  # saved?
+  it { album.saved?.must_equal true }
+  it { hit.saved?.must_equal true }
+  it { song1.saved?.must_equal true }
+  it { song1.saved?.must_equal true }
+  it { band.saved?.must_equal true }
+  it { label.saved?.must_equal true }
+
+
+  describe "save: false" do
+    let (:form) {
+      Class.new(Reform::Form) do
+        property :hit do
+          property :title
+        end
+
+        collection :songs, :save => false do
+          property :title
+        end
+
+        property :band do # yepp, people do crazy stuff like that.
+          property :label, :save => false do
+            property :name
+          end
+          # TODO: make band a required object.
+        end
+      end
+    }
+
+    subject { form.new(album) }
+
+    # synced?
+    it { hit.title.must_equal "Roxanne" }
+    it { song1.title.must_equal "Fallout" }
+    it { song2.title.must_equal "Roxanne" }
+    it { label.name.must_equal "Polydor" }
+
+    # saved?
+    it { album.saved?.must_equal true }
+    it { hit.saved?.must_equal true }
+    it { song1.saved?.must_equal nil }
+    it { song1.saved?.must_equal nil }
+    it { band.saved?.must_equal true }
+    it { label.saved?.must_equal nil }
+  end
+end

data/test/setup_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class SetupTest < BaseTest
+  describe "populated" do
+    subject { AlbumForm.new(Album.new("Best Of", hit, [Song.new("Fallout"), Song.new("Roxanne")])) }
+
+    it { subject.title.must_equal "Best Of" }
+
+
+    it { subject.hit.must_be_kind_of Reform::Form }
+    it { subject.hit.title.must_equal "Roxanne" }
+
+    it { subject.songs.must_be_kind_of Array }
+    it { subject.songs.size.must_equal 2 }
+
+    it { subject.songs[0].must_be_kind_of Reform::Form }
+    it { subject.songs[0].title.must_equal "Fallout" }
+
+    it { subject.songs[1].must_be_kind_of Reform::Form }
+    it { subject.songs[1].title.must_equal "Roxanne" }
+  end
+
+
+  describe "empty" do
+    subject { AlbumForm.new(Album.new) }
+
+    it { subject.title.must_equal nil }
+
+
+# TODO: discuss and implement.
+    # it { subject.hit.must_be_kind_of Reform::Form }
+    # it { subject.hit.title.must_equal nil }
+
+
+    # it { subject.songs.must_be_kind_of Reform::Form::Forms }
+    # it { subject.songs.size.must_equal 0 }
+  end
+end