reform 1.2.6 → 2.0.0.beta1

data/lib/reform/form/validation/unique_validator.rb

@@ -0,0 +1,13 @@
+class Reform::Form::UniqueValidator < ActiveModel::EachValidator
+  def validate_each(form, attribute, value)
+    # search for models with attribute equals to form field value
+    query = form.model.class.where(attribute => value)
+
+    # if model persisted, excluded own model from query
+    query = query.merge(form.model.class.where("id <> ?", form.model.id)) if form.model.persisted?
+
+    # if any models found, add error on attribute
+    form.errors.add(attribute, "#{attribute} must be unique.") if query.any?
+  end
+end
+

data/lib/reform/version.rb

@@ -1,3 +1,3 @@
 module Reform
-  VERSION = "1.2.6"
+  VERSION = "2.0.0.beta1"
 end

data/reform.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'reform/version'
@@ -8,8 +7,8 @@ Gem::Specification.new do |spec|
   spec.version       = Reform::VERSION
   spec.authors       = ["Nick Sutterer", "Garrett Heinlen"]
   spec.email         = ["apotonick@gmail.com", "heinleng@gmail.com"]
-  spec.description   = %q{Freeing your AR models from form logic.}
-  spec.summary       = %q{Decouples your models from form by giving you form objects with validation, presentation, workflows and security.}
+  spec.description   = %q{Form object decoupled from models.}
+  spec.summary       = %q{Form object decoupled from models with validation, population and presentation.}
   spec.homepage      = "https://github.com/apotonick/reform"
   spec.license       = "MIT"
 
@@ -18,13 +17,14 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency             "representable",  "~> 2.1.0"
-  spec.add_dependency             "disposable",     "~> 0.0.5"
+  spec.add_dependency             "representable",  ">= 2.2.2"
+  spec.add_dependency             "disposable",     "~> 0.1.2"
   spec.add_dependency             "uber",           "~> 0.0.11"
   spec.add_dependency             "activemodel"
-  spec.add_development_dependency "bundler",        "~> 1.3"
+
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest",       "5.4.1"
+  spec.add_development_dependency "minitest"
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "virtus"

data/test/active_model_test.rb

@@ -1,5 +1,20 @@
 require 'test_helper'
 
+module IsolatedRailsEngine
+  def self.use_relative_model_naming?
+    true
+  end
+
+  class Lyric < ActiveRecord::Base
+  end
+end
+
+module NormalRailsEngine
+  class Lyric < ActiveRecord::Base
+  end
+end
+
+
 class NewActiveModelTest < MiniTest::Spec # TODO: move to test/rails/
   class SongForm < Reform::Form
     include Reform::Form::ActiveModel
@@ -31,6 +46,27 @@ class NewActiveModelTest < MiniTest::Spec # TODO: move to test/rails/
     it { class_with_model.model_name.must_be_kind_of ActiveModel::Name }
     it { class_with_model.model_name.to_s.must_equal "Album" }
 
+    let (:class_with_isolated_model) {
+      Class.new(Reform::Form) do
+        include Reform::Form::ActiveModel
+
+        model "isolated_rails_engine/lyric", namespace: "isolated_rails_engine"
+      end
+    }
+
+    it { class_with_isolated_model.model_name.must_be_kind_of ActiveModel::Name }
+    it { class_with_isolated_model.model_name.to_s.must_equal "IsolatedRailsEngine::Lyric" }
+
+    let (:class_with_namespace_model) {
+      Class.new(Reform::Form) do
+        include Reform::Form::ActiveModel
+
+        model "normal_rails_engine/lyric"
+      end
+    }
+
+    it { class_with_namespace_model.model_name.must_be_kind_of ActiveModel::Name }
+    it { class_with_namespace_model.model_name.to_s.must_equal "NormalRailsEngine::Lyric" }
 
     let (:subclass_of_class_with_model) {
       Class.new(class_with_model)
@@ -39,6 +75,13 @@ class NewActiveModelTest < MiniTest::Spec # TODO: move to test/rails/
     it { subclass_of_class_with_model.model_name.must_be_kind_of ActiveModel::Name }
     it { subclass_of_class_with_model.model_name.to_s.must_equal 'Album' }
 
+    unless Reform.rails3_0?
+      it { form.class.model_name.route_key.must_equal "new_active_model_test_songs" }
+      it { class_with_model.model_name.route_key.must_equal "albums" }
+      it { class_with_isolated_model.model_name.route_key.must_equal "lyrics" }
+      it { class_with_namespace_model.model_name.route_key.must_equal "normal_rails_engine_lyrics" }
+      it { subclass_of_class_with_model.model_name.route_key.must_equal 'albums' }
+    end
 
     describe "class named Song::Form" do
       it do

data/test/changed_test.rb

@@ -1,69 +1,41 @@
 require 'test_helper'
 require 'reform/form/coercion'
 
-class ChangedTest < BaseTest
-  class AlbumForm < Reform::Form
-    include Coercion
-
-    property :title
+class ChangedTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
 
-    property :hit do
-      property :title
-      property :length, type: Integer
-      validates :title, :presence => true
-    end
+  class AlbumForm < Reform::Form
+    property :name
 
     collection :songs do
       property :title
-      validates :title, :presence => true
-    end
 
-    property :band do # yepp, people do crazy stuff like that.
-      property :label do
+      property :composer do
         property :name
-        property :location
-        validates :name, :presence => true
       end
-      # TODO: make band a required object.
     end
-
-    validates :title, :presence => true
   end
 
-  Label = Struct.new(:name, :location)
+  let (:song_with_composer) { Song.new("Resist Stance", nil, composer) }
+  let (:composer)           { Artist.new("Greg Graffin") }
+  let (:album)              { Album.new("The Dissent Of Man", [song_with_composer]) }
 
-  # setup: changed? is always false
-  let (:form) { AlbumForm.new(Album.new("Drawn Down The Moon", Song.new("The Ripper", 9), [Song.new("Black Candles"), Song.new("The Ripper")], Band.new(Label.new("Cleopatra Records")))) }
+  let (:form) { AlbumForm.new(album) }
 
-  it { form.changed?(:title).must_equal false }
-  it { form.changed?("title").must_equal false }
-  it { form.hit.changed?(:title).must_equal false }
-  it { form.hit.changed?.must_equal false }
-
-
-  describe "#validate" do
-    before { form.validate(
-      "title" => "Five", # changed.
-      "hit"   => {"title"  => "The Ripper", # same, but overridden.
-                  "length" => "9"}, # gets coerced, then compared, so not changed.
-      "band"  => {"label" => {"name" => "Shrapnel Records"}} # only label.name changes.
-    ) }
-
-    it { form.changed?(:title).must_equal true }
-
-    # it { form.changed?(:hit).must_equal false }
-
-    # overridden with same value is no change.
-    it { form.hit.changed?(:title).must_equal false }
-    # coerced value is identical to form's => not changed.
-    it { form.hit.changed?(:length).must_equal false }
-
-    # it { form.changed?(:band).must_equal true }
-    # it { form.band.changed?(:label).must_equal true }
-    it { form.band.label.changed?(:name).must_equal true }
+  # nothing changed after setup.
+  it do
+    form.changed?(:name).must_equal false
+    form.songs[0].changed?(:title).must_equal false
+    form.songs[0].composer.changed?(:name).must_equal false
+  end
 
-    # not present key/value in #validate is no change.
-    it { form.band.label.changed?(:location).must_equal false }
-    # TODO: parent form changed when child has changed!
+  # after validate, things might have changed.
+  it do
+    form.validate("name" => "Out Of Bounds", "songs" => [{"composer" => {"name" => "Ingemar Jansson & Mikael Danielsson"}}])
+    form.changed?(:name).must_equal true
+    form.songs[0].changed?(:title).must_equal false
+    form.songs[0].composer.changed?(:name).must_equal true
   end
 end

data/test/coercion_test.rb

@@ -9,20 +9,17 @@ class CoercionTest < BaseTest
   end
 
   class Form < Reform::Form
-    include Coercion
+    # include Coercion
 
     property :released_at, :type => DateTime
 
     property :hit do
-      # include Coercion
       property :length, :type => Integer
       property :good,   :type => Virtus::Attribute::Boolean
     end
 
     property :band do
-      include Coercion
       property :label do
-        include Coercion
         property :value, :type => Irreversible
       end
     end
@@ -66,7 +63,4 @@ class CoercionTest < BaseTest
   end
 
   # save
-
-
-
 end

data/test/composition_test.rb

@@ -1,51 +1,145 @@
-class CompositionTest < ReformSpec
-  class SongAndArtist < Reform::Composition
-    map({:artist => [[:name]], :song => [[:title]]}) #SongAndArtistMap.representable_attrs
+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
+
+    validates :name, :title, :channel, :presence => true
+
+    property :band,           :on => :song do
+      property :title
+    end
   end
 
-  let (:comp) { SongAndArtist.new(:artist => @artist=OpenStruct.new, :song => rio) }
+  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 }
 
-  it "delegates to models as defined" do
-    comp.name.must_equal nil
-    comp.title.must_equal "Rio"
+  # #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
 
-  it "raises when non-mapped property" do
-    assert_raises NoMethodError do
-      comp.raise_an_exception
+  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
-  end
 
-  describe "::from" do
-    it "creates the same mapping" do
-      comp =
-      Reform::Composition.from(
-          Class.new(Reform::Representer) do
-            property :name,  :on => :artist
-            property :title, :on => :song
-          end
-        ).
-      new(:artist => duran, :song => rio)
+    it "provides nested symbolized hash as second block argument" do
+      form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "channel" => "JJJ", "captcha" => "wonderful")
+
+      hash = nil
 
-      comp.name.must_equal "Duran Duran"
-      comp.title.must_equal "Rio"
+      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
-  end
 
+    it "xxx pushes data to models and calls #save when no block passed" do
+      song.extend(Saveable)
+      requester.extend(Saveable)
+      band.extend(Saveable)
 
-  describe "#nested_hash_for" do
-    it "returns nested hash" do
-      comp.nested_hash_for(:name => "Jimi Hendrix", :title => "Fire").must_equal({:artist=>{:name=>"Jimi Hendrix"}, :song=>{:title=>"Fire"}})
+      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 "works with strings" do
-      comp.nested_hash_for("name" => "Jimi Hendrix", "title" => "Fire").must_equal({:artist=>{:name=>"Jimi Hendrix"}, :song=>{:title=>"Fire"}})
+    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 "works with strings in map" do
-      Class.new(Reform::Composition) do
-        map(:artist => [["name"]])
-      end.new({}).nested_hash_for(:name => "Jimi Hendrix").must_equal({:artist=>{:name=>"Jimi Hendrix"}})
+    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
+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,105 +1,46 @@
 require 'test_helper'
 
-class ContractTest < BaseTest
-  class AlbumContract < Reform::Contract
-    property :title
-    validates :title, :presence => true, :length => {:minimum => 3}
+class ContractTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
 
-    property :hit do
-      property :title
-      validates :title, :presence => true
-    end
+  class ArtistForm < Reform::Form
+    property :name
+  end
+
+  class AlbumForm < Reform::Contract
+    property :name
+    validates :name, presence: true
 
     collection :songs do
       property :title
-      validates :title, :presence => true
-    end
-
-    validates :songs, :length => {:minimum => 4}
-
-    property :band do # yepp, people do crazy stuff like that.
-      validates :label, :presence => true
+      validates :title, presence: true
 
-      property :label do
+      property :composer do
+        validates :name, presence: true
         property :name
-        validates :name, :presence => true
       end
-      # TODO: make band a required object.
     end
-  end
-
-  let (:album) { Album.new(nil, Song.new, [Song.new, Song.new], Band.new() ) }
-  subject { AlbumContract.new(album) }
-
-
-  describe "invalid" do
-    before {
-      res = subject.validate
-      res.must_equal false
-    }
-
-    it { subject.errors.messages.must_equal({:"hit.title"=>["can't be blank"], :"songs.title"=>["can't be blank"], :"band.label"=>["can't be blank"], :songs=>["is too short (minimum is 4 characters)"], :title=>["can't be blank", "is too short (minimum is 3 characters)"]}) }
-  end
 
-
-  describe "valid" do
-    let (:album) { Album.new(
-      "Keeper Of The Seven Keys",
-      nil,
-      [Song.new("Initiation"), Song.new("I'm Alive"), Song.new("A Little Time"), Song.new("Future World"),],
-      Band.new(Label.new("Noise"))
-    ) }
-
-    before { subject.validate.must_equal true }
-
-    it { subject.errors.messages.must_equal({}) }
+    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", [song, song_with_composer], artist) }
 
-  describe "::representer" do
-    # without name will always iterate.
-    it do
-      names = []
-      AlbumContract.representer { |dfn| names << dfn.name }
-      names.must_equal ["hit", "songs", "band"]
-
-      # this doesn't cache.
-      names = []
-      AlbumContract.representer { |dfn| names << dfn.name }
-      names.must_equal ["hit", "songs", "band"]
-    end
-
-    # with name caches representer per class and runs once.
-    it do
-      names = []
-      AlbumContract.representer(:sync) { |dfn| names << dfn.name }
-      names.must_equal ["hit", "songs", "band"]
-
-      # this does cache.
-      names = []
-      AlbumContract.representer(:sync) { |dfn| names << dfn.name }
-      names.must_equal []
-    end
-
-    # it allows iterating all properties, not only nested.
-    it do
-      names = []
-      AlbumContract.representer(:save, all: true) { |dfn| names << dfn.name }
-      names.must_equal ["title", "hit", "songs", "band"]
-
-      names = []
-      AlbumContract.representer(:save, all: true) { |dfn| names << dfn.name }
-      names.must_equal []
-    end
-
-    # test :superclass?
-  end
+  let (:form) { AlbumForm.new(album) }
 
-  class SongContract < Reform::Contract
-    property :title, readable: true, type: String
+  # accept `property form: SongForm`.
+  it do
+    form.artist.must_be_instance_of ArtistForm
   end
 
   describe "#options_for" do
-    it { SongContract.new(OpenStruct.new).options_for(:title)[:coercion_type].must_equal String }
+    it { AlbumForm.options_for(:name).inspect.must_match "#<Representable::Definition ==>name @options" }
+    it { AlbumForm.new(album).options_for(:name).inspect.must_match "#<Representable::Definition ==>name @options" }
   end
-end
+end