reform 2.2.4 → 2.3.3

data/gemfiles/Gemfile.disposable-0.3

@@ -1,6 +0,0 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in reform.gemspec
-gemspec :path => '../'
-
-gem 'minitest'

data/lib/reform/contract/errors.rb

@@ -1,43 +0,0 @@
-class Reform::Contract::Errors
-  def initialize(*)
-    @errors = {}
-  end
-
-  module Merge
-    def merge!(errors, prefix)
-      errors.messages.each do |field, msgs|
-        unless field.to_sym == :base
-          field = (prefix+[field]).join(".").to_sym # TODO: why is that a symbol in Rails?
-        end
-
-        msgs.each do |msg|
-          next if messages[field] and messages[field].include?(msg)
-          add(field, msg)
-        end # Forms now contains a plain errors hash. the errors for each item are still available in item.errors.
-      end
-    end
-
-    def to_s
-      messages.inspect
-    end
-  end
-  include Merge
-
-  def add(field, message)
-    @errors[field] ||= []
-    @errors[field] << message
-  end
-
-  def messages
-    @errors
-  end
-
-  def empty?
-    @errors.empty?
-  end
-
-  # needed by Rails form builder.
-  def [](name)
-    @errors[name] || []
-  end
-end

data/lib/reform/form/mongoid.rb

@@ -1,37 +0,0 @@
-module Reform::Form::Mongoid
-  def self.included(base)
-    base.class_eval do
-      register_feature Reform::Form::Mongoid
-      include Reform::Form::ActiveModel
-      include Reform::Form::ORM
-      extend ClassMethods
-    end
-  end
-
-  module ClassMethods
-    def validates_uniqueness_of(attribute, options={})
-      options = options.merge(:attributes => [attribute])
-      validates_with(UniquenessValidator, options)
-    end
-    def i18n_scope
-      :mongoid
-    end
-  end
-
-
-  def self.mongoid_namespace
-    if mongoid_is_4_or_more?
-      'Validatable'
-    else
-      'Validations'
-    end
-  end
-
-  def self.mongoid_is_4_or_more?
-    Mongoid::VERSION.split('.').first.to_i >= 4
-  end
-
-  UniquenessValidator = Class.new("::Mongoid::#{mongoid_namespace}::UniquenessValidator".constantize) do
-    include Reform::Form::ORM::UniquenessValidator
-  end
-end

data/lib/reform/form/orm.rb

@@ -1,26 +0,0 @@
-module Reform::Form::ORM
-  def model_for_property(name)
-    return model unless is_a?(Reform::Form::Composition) # i am too lazy for proper inheritance. there should be a ActiveRecord::Composition that handles this.
-
-    model_name = options_for(name)[:on]
-    model[model_name]
-  end
-
-  module UniquenessValidator
-    # when calling validates it should create the Vali instance already and set @klass there! # TODO: fix this in AM.
-    def validate(form)
-      property = attributes.first
-
-      # here is the thing: why does AM::UniquenessValidator require a filled-out record to work properly? also, why do we need to set
-      # the class? it would be way easier to pass #validate a hash of attributes and get back an errors hash.
-      # the class for the finder could either be infered from the record or set in the validator instance itself in the call to ::validates.
-      record = form.model_for_property(property)
-      record.send("#{property}=", form.send(property))
-
-      @klass = record.class # this is usually done in the super-sucky #setup method.
-      super(record).tap do |res|
-        form.errors.add(property, record.errors.first.last) if record.errors.present?
-      end
-    end
-  end
-end

data/lib/reform/mongoid.rb

@@ -1,4 +0,0 @@
-require 'reform/form/active_model'
-require 'reform/form/orm'
-require 'reform/form/mongoid'
-require 'reform/form/active_model/model_reflections' # only load this in AR context as simple_form currently is bound to AR.

data/test/call_test.rb

@@ -1,23 +0,0 @@
-require "test_helper"
-
-class CallTest < Minitest::Spec
-  Song = Struct.new(:title)
-
-  class SongForm < Reform::Form
-    property :title
-
-    validation do
-      key(:title).required
-    end
-  end
-
-  let (:form) { SongForm.new(Song.new) }
-
-  it { form.(title: "True North").success?.must_equal true }
-  it { form.(title: "True North").failure?.must_equal false }
-  it { form.(title: "").success?.must_equal false }
-  it { form.(title: "").failure?.must_equal true }
-
-  it { form.(title: "True North").errors.messages.must_equal({}) }
-  it { form.(title: "").errors.messages.must_equal({:title=>["must be filled"]}) }
-end

data/test/composition_test.rb

@@ -1,149 +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, :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

@@ -1,77 +0,0 @@
-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/deprecation_test.rb

@@ -1,27 +0,0 @@
-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/errors_test.rb

@@ -1,165 +0,0 @@
-require "test_helper"
-
-class ErrorsTest < MiniTest::Spec
-  class AlbumForm < Reform::Form
-    property :title
-
-    property :hit do
-      property :title
-      validation do
-        required(:title).filled
-      end
-    end
-
-    collection :songs do
-      property :title
-      validation do
-        required(:title).filled
-      end
-    end
-
-    property :band do # yepp, people do crazy stuff like that.
-      property :name
-      property :label do
-        property :name
-        validation do
-          required(:name).filled
-        end
-      end
-      # TODO: make band a required object.
-
-      validation do
-        # required(:name).filled(:music_taste_ok?)
-
-        configure do
-          config.messages_file = "test/validation/errors.yml"
-
-          def music_taste_ok?(value)
-            value != "Nickelback"
-            # errors.add(:base, "You are a bad person") if name == "Nickelback"
-          end
-        end
-      end
-      # validate :music_taste_ok?
-
-    # private
-    #   def music_taste_ok?
-    #     errors.add(:base, "You are a bad person") if name == "Nickelback"
-    #   end
-    end
-
-    validation do
-      required(:title).filled
-    end
-  end
-
-  let (:album) do
-    OpenStruct.new(
-      :title  => "Blackhawks Over Los Angeles",
-      :hit    => song,
-      :songs  => songs, # TODO: document this requirement,
-
-      :band => Struct.new(:name, :label).new("Epitaph", OpenStruct.new),
-    )
-  end
-  let (:song)  { OpenStruct.new(:title => "Downtown") }
-  let (:songs) { [song=OpenStruct.new(:title => "Calling"), song] }
-  let (:form)  { AlbumForm.new(album) }
-
-
-  describe "incorrect #validate" do
-    before { form.validate(
-      "hit"   =>{"title" => ""},
-      "title" => "",
-      "songs" => [{"title" => ""}, {"title" => ""}]) } # FIXME: what happens if item is missing?
-
-    it do
-      form.errors.messages.must_equal({
-        :title  => ["must be filled"],
-        :"hit.title"=>["must be filled"],
-        :"songs.title"=>["must be filled"],
-        :"band.label.name"=>["is missing"]
-      })
-    end
-
-    it do
-      #form.errors.must_equal({:title  => ["must be filled"]})
-      # TODO: this should only contain local errors?
-    end
-
-    # nested forms keep their own Errors:
-    it { form.hit.errors.messages.must_equal({:title=>["must be filled"]}) }
-    it { form.songs[0].errors.messages.must_equal({:title=>["must be filled"]}) }
-
-    it do
-      form.errors.messages.must_equal({
-        :title        => ["must be filled"],
-        :"hit.title"  => ["must be filled"],
-        :"songs.title"=> ["must be filled"],
-        :"band.label.name"=>["is missing"]
-      })
-    end
-  end
-
-
-  describe "#validate with main form invalid" do
-    it do
-      form.validate("title"=>"", "band"=>{"label"=>{:name => "Fat Wreck"}}).must_equal false
-      form.errors.messages.must_equal({:title=>["must be filled"]})
-    end
-  end
-
-
-  describe "#validate with middle nested form invalid" do
-    before { @result = form.validate("hit"=>{"title" => ""}, "band"=>{"label"=>{:name => "Fat Wreck"}}) }
-
-    it { @result.must_equal false }
-    it { form.errors.messages.must_equal({:"hit.title"=>["must be filled"]}) }
-  end
-
-
-  describe "#validate with collection form invalid" do
-    before { @result = form.validate("songs"=>[{"title" => ""}], "band"=>{"label"=>{:name => "Fat Wreck"}}) }
-
-    it { @result.must_equal false }
-    it { form.errors.messages.must_equal({:"songs.title"=>["must be filled"]}) }
-  end
-
-
-  describe "#validate with collection and 2-level-nested invalid" do
-    before { @result = form.validate("songs"=>[{"title" => ""}], "band" => {"label" => {}}) }
-
-    it { @result.must_equal false }
-    it { form.errors.messages.must_equal({:"songs.title"=>["must be filled"], :"band.label.name"=>["is missing"]}) }
-  end
-
-  describe "#validate with nested form using :base invalid" do
-    it do
-      result = form.validate("songs"=>[{"title" => "Someday"}], "band" => {"name" => "Nickelback", "label" => {"name" => "Roadrunner Records"}})
-      result.must_equal false
-      form.errors.messages.must_equal({:"band.name"=>["You are a bad person"]})
-    end
-  end
-
-  describe "correct #validate" do
-    before { @result = form.validate(
-      "hit"   => {"title" => "Sacrifice"},
-      "title" => "Second Heat",
-      "songs" => [{"title"=>"Heart Of A Lion"}],
-      "band"  => {"label"=>{:name => "Fat Wreck"}}
-      ) }
-
-    it { @result.must_equal true }
-    it { form.hit.title.must_equal "Sacrifice" }
-    it { form.title.must_equal "Second Heat" }
-    it { form.songs.first.title.must_equal "Heart Of A Lion" }
-  end
-
-
-  describe "Errors#to_s" do
-    before { form.validate("songs"=>[{"title" => ""}], "band" => {"label" => {}}) }
-
-    # to_s is aliased to messages
-    it { form.errors.to_s.must_equal "{:\"songs.title\"=>[\"must be filled\"], :\"band.label.name\"=>[\"is missing\"]}" }
-  end
-end