reform 1.2.6 → 2.0.0.beta1

data/lib/reform/representer.rb

@@ -1,84 +0,0 @@
-require 'representable/hash'
-require 'representable/decorator'
-
-module Reform
-  class Representer < Representable::Decorator
-    include Representable::Hash::AllowSymbols
-
-    extend Uber::InheritableAttr
-    inheritable_attr :options # FIXME: this doesn't need to be inheritable.
-    # self.options = {}
-
-
-    class Options < ::Hash
-      def include!(names)
-        includes.push(*names) #if names.size > 0
-        self
-      end
-
-      def exclude!(names)
-        excludes.push(*names) #if names.size > 0
-        self
-      end
-
-      def excludes
-        self[:exclude] ||= []
-      end
-
-      def includes
-        self[:include] ||= []
-      end
-    end
-
-
-    include Representable::Hash
-
-    # Returns hash of all property names.
-    def self.fields(&block)
-      representable_attrs.find_all(&block).map(&:name)
-    end
-
-    def self.each(only_form=true, &block)
-      definitions = representable_attrs
-      definitions = representable_attrs.find_all { |attr| attr[:form] } if only_form
-
-      definitions.each(&block)
-      self
-    end
-
-    def self.for(options)
-      clone.tap do |representer|
-        representer.options = options
-      end
-    end
-
-    def self.default_inline_class
-      options[:form_class]
-    end
-
-    def self.clone # called in inheritable_attr :representer_class.
-      Class.new(self) # By subclassing, representable_attrs.clone is called.
-    end
-
-  private
-
-    # Inline forms always get saved in :extend.
-    def self.build_inline(base, features, name, options, &block)
-      name = name.to_s.singularize.camelize
-
-      features = options[:features]
-
-      Class.new(base || default_inline_class) do
-        include *features
-
-        class_eval &block
-
-        @form_name = name
-
-        def self.name # needed by ActiveModel::Validation and I18N.
-          @form_name
-        end
-      end
-    end
-  end
-end

data/test/empty_test.rb

@@ -1,58 +0,0 @@
-require 'test_helper'
-
-
-class DeprecatedVirtualTest < MiniTest::Spec # TODO: remove me in 2.0.
-  Location = Struct.new(:country)
-
-  class LocationForm < Reform::Form
-    property :country, virtual: true # this becomes readonly: 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
-
-class DeprecatedEmptyTest < MiniTest::Spec # don't read, don't write
-  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) }
-
-  it {
-    form.validate("password" => "123", "password_confirmation" => "321")
-
-    form.password.must_equal "123"
-    form.password_confirmation.must_equal "321" # this is still readable in the UI.
-
-    form.sync
-    cred.password.must_equal "123"
-
-    hash = {}
-    form.save do |nested|
-      hash = nested
-    end
-
-    hash.must_equal("password"=> "123", "password_confirmation" => "321")
-  }
-end

data/test/form_composition_test.rb

@@ -1,145 +0,0 @@
-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, :empty => true, :on => :song
-    property :requester,      :on => :requester
-    property :captcha,        :on => :song, :empty => true
-
-    validates :name, :title, :channel, :presence => true
-
-    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.model.must_be_kind_of Reform::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/nested_form_test.rb

@@ -1,197 +0,0 @@
-require 'test_helper'
-
-class NestedFormTest < MiniTest::Spec
-  class AlbumForm < Reform::Form
-    property :title
-
-    # class SongForm < Reform::Form
-    #   property :title
-    #   validates :title, :presence => true
-    # end
-
-    #form :hit, :class => SongForm
-    property :hit do
-      property :title
-      validates :title, :presence => true
-    end
-
-    collection :songs do
-      property :title
-      validates :title, :presence => true
-    end
-
-    validates :title, :presence => true
-  end
-
-  # AlbumForm::collection :songs, :form => SongForm
-  # should be: AlbumForm.new(songs: [Song, Song])
-
-  let (:album) do
-    OpenStruct.new(
-      :title  => "Blackhawks Over Los Angeles",
-      :hit    => song,
-      :songs  => songs # TODO: document this requirement
-    )
-  end
-  let (:song)  { OpenStruct.new(:title => "Downtown") }
-  let (:songs) { [OpenStruct.new(:title => "Calling")] }
-  let (:form)  { AlbumForm.new(album) }
-
-  it "responds to #save" do
-    hsh = nil
-    form.save do |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 Array
-  end
-
-  describe "#initialize" do
-    describe "with empty object and no cardinality" do
-      let(:form) { AlbumForm.new(OpenStruct.new) }
-
-      it "allows initialization with empty properties" do
-        form
-      end
-
-      it "allows #validate" do
-        form.validate({})
-        form.errors.messages.must_equal(:title=>["can't be blank"])
-      end
-      # it "must support #validate when initialized with empty properties" do
-      #   form.validate({})
-      #   form.errors.messages.must_equal(:title=>["can't be blank"], :"hit.title"=>["can't be blank"], :"songs.title"=>["can't be blank"])
-      # end
-      # it "must support #validate with attributes when initialized with empty properties" do
-      #   form.validate("hit"=>{"title"=>"Downtown"}, "title" => "Blackhawks Over Los Angeles", "songs"=>[{"title"=>"Calling"}])
-      #   form.title.must_eql "Blackhawks Over Los Angeles"
-      #   form.errors.messages.must_equal([])
-      # end
-    end
-
-
-  end
-
-
-  describe "rendering" do
-    it { form.title.must_equal "Blackhawks Over Los Angeles" }
-    it { form.hit.title.must_equal "Downtown" }
-    it { form.songs[0].title.must_equal "Calling" }
-  end
-
-  describe "#save" do
-    before { @result = form.validate(
-      "hit"   =>{"title" => "Sacrifice"},
-      "title" =>"Second Heat",
-      "songs" => [{"title" => "Scarified"}])
-    }
-
-    it "updates internal Fields" do
-      data = {}
-
-      form.save do |nested_hash|
-        data[:title]        = form.title
-        data[:hit_title]    = form.hit.title
-        data[:first_title]  = form.songs.first.title
-      end
-
-      data.must_equal(:title=>"Second Heat", :hit_title => "Sacrifice", :first_title => "Scarified")
-    end
-
-    it "returns nested hash with indifferent access" do
-      nested = nil
-
-      form.save do |nested_hash|
-        nested = nested_hash
-      end
-
-      nested.must_equal("title"=>"Second Heat", "hit"=>{"title"=>"Sacrifice"}, "songs"=>[{"title"=>"Scarified"}])
-
-      nested[:title].must_equal "Second Heat"
-      nested["title"].must_equal "Second Heat"
-      nested[:hit][:title].must_equal "Sacrifice"
-      nested["hit"]["title"].must_equal "Sacrifice"
-    end
-
-    it "pushes data to models" do
-      form.save
-
-      album.title.must_equal "Second Heat"
-      song.title.must_equal "Sacrifice"
-      songs.first.title.must_equal "Scarified"
-    end
-
-    describe "with invalid args" do
-      it "allows empty collection values" do
-        form.validate({})
-
-        form.songs.size.must_equal 1
-        form.songs[0].title.must_equal "Scarified"
-      end
-    end
-  end
-
-  # describe "with aliased nested form name" do
-  #   let (:form) do
-  #     Class.new(Reform::Form) do
-  #       form :hit, :class => AlbumForm::SongForm, :as => :song
-  #     end.new(OpenStruct.new(:hit => OpenStruct.new(:title => "")))
-  #   end
-
-  #   it "uses alias in errors" do
-  #     form.validate({})
-  #     form.errors.messages.must_equal({})
-  #   end
-  # end
-
-  class ExplicitNestedFormTest < MiniTest::Spec
-    let (:song)  { OpenStruct.new(:title => "Downtown") }
-    let (:album) do
-      OpenStruct.new(
-        :title  => "Blackhawks Over Los Angeles",
-        :hit    => song,
-      )
-    end
-    let (:form) { AlbumForm.new(album) }
-
-    class SongForm < Reform::Form
-      property :title
-      validates_presence_of :title
-    end
-
-    class AlbumForm < Reform::Form
-      property :title
-
-      property :hit, :form => SongForm #, :parse_strategy => :sync, :instance => true
-    end
-
-
-    it "allows rendering" do
-      form.hit.title.must_equal "Downtown"
-    end
-
-    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 Array
-    end
-
-    describe "#validate" do
-      it "keeps Form instances" do
-        form.validate("songs"=>[{"title" => "Atwa"}])
-        form.songs.first.must_be_kind_of Reform::Form
-      end
-    end
-  end
-end