reform 2.0.5 → 2.1.0.rc1

data/test/validate_test.rb

@@ -143,7 +143,7 @@ class ValidateWithoutConfigurationTest < MiniTest::Spec
   end
 end
 
-class ValidateWithDeserializerOptionTest < MiniTest::Spec
+class ValidateWithInternalPopulatorOptionTest < MiniTest::Spec
   Song  = Struct.new(:title, :album, :composer)
   Album = Struct.new(:name, :songs, :artist)
   Artist = Struct.new(:name)
@@ -153,21 +153,20 @@ class ValidateWithDeserializerOptionTest < MiniTest::Spec
     validates :name, presence: true
 
     collection :songs,
-      deserializer: {instance: lambda { |fragment, index, options|
-              collection = options.binding.get
-              (item = collection[index]) ? item : collection.insert(index, Song.new) },
-      setter: nil} do
+      internal_populator: lambda { |input, options|
+              collection = options[:represented].songs
+              (item = collection[options[:index]]) ? item : collection.insert(options[:index], Song.new) } do
 
       property :title
       validates :title, presence: true
 
-      property :composer, deserializer: { instance: lambda { |fragment, options| (item = options.binding.get) ? item : Artist.new } } do
+      property :composer, internal_populator: lambda { |input, options| (item = options[:represented].composer) ? item : Artist.new } do
         property :name
         validates :name, presence: true
       end
     end
 
-    property :artist, deserializer: { instance: lambda { |fragment, options| (item = options.binding.get) ? item : Artist.new } } do
+    property :artist, internal_populator: lambda { |input, options| (item = options[:represented].artist) ? item : Artist.new } do
       property :name
       validates :name, presence: true
     end

data/test/validation/activemodel_validation_test.rb

@@ -0,0 +1,252 @@
+require "test_helper"
+require "reform/form/lotus"
+
+class ActiveModelValidationTest < MiniTest::Spec
+  Session = Struct.new(:username, :email, :password, :confirm_password)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
+
+  class SessionForm < Reform::Form
+    include Reform::Form::ActiveModel::Validations
+
+
+    property :username
+    property :email
+    property :password
+    property :confirm_password
+
+    validation :default do
+      validates :username, presence: true
+      validates :email, presence: true
+    end
+
+    validation :email, if: :default do
+      # validate :email_ok? # FIXME: implement that.
+      validates :email, length: {is: 3}
+    end
+
+    validation :nested, if: :default do
+      validates :password, presence: true, length: {is: 1}
+    end
+
+    validation :confirm, if: :default, after: :email do
+      validates :confirm_password, length: {is: 2}
+    end
+  end
+
+  let (:form) { SessionForm.new(Session.new) }
+
+  # valid.
+  it do
+    form.validate({username: "Helloween", email: "yep", password: "9", confirm_password:"dd"}).must_equal true
+    form.errors.messages.inspect.must_equal "{}"
+  end
+
+  # invalid.
+  it do
+    form.validate({}).must_equal false
+    form.errors.messages.inspect.must_equal "{:username=>[\"can't be blank\"], :email=>[\"can't be blank\"]}"
+  end
+
+  # partially invalid.
+  # 2nd group fails.
+  let (:character) { self.class.rails4_2? ? :character : :characters}
+  it do
+    form.validate(username: "Helloween", email: "yo").must_equal false
+    form.errors.messages.inspect.must_equal "{:email=>[\"is the wrong length (should be 3 characters)\"], :confirm_password=>[\"is the wrong length (should be 2 characters)\"], :password=>[\"can't be blank\", \"is the wrong length (should be 1 #{character})\"]}"
+  end
+  # 3rd group fails.
+  it do
+    form.validate(username: "Helloween", email: "yo!").must_equal false
+    form.errors.messages.inspect.must_equal"{:confirm_password=>[\"is the wrong length (should be 2 characters)\"], :password=>[\"can't be blank\", \"is the wrong length (should be 1 #{character})\"]}"
+  end
+  # 4th group with after: fails.
+  it do
+    form.validate(username: "Helloween", email: "yo!", password: "1", confirm_password: "9").must_equal false
+    form.errors.messages.inspect.must_equal "{:confirm_password=>[\"is the wrong length (should be 2 characters)\"]}"
+  end
+
+
+  describe "implicit :default group" do
+    # implicit :default group.
+    class LoginForm < Reform::Form
+      include Reform::Form::ActiveModel::Validations
+
+
+      property :username
+      property :email
+      property :password
+      property :confirm_password
+
+      validates :username, presence: true
+      validates :email, presence: true
+      validates :password, presence: true
+
+      validation :after_default, if: :default do
+        validates :confirm_password, presence: true
+      end
+    end
+
+    let (:form) { LoginForm.new(Session.new) }
+
+    # valid.
+    it do
+      form.validate({username: "Helloween", email: "yep", password: "9", confirm_password: 9}).must_equal true
+      form.errors.messages.inspect.must_equal "{}"
+    end
+
+    # invalid.
+    it do
+      form.validate({password: 9}).must_equal false
+      form.errors.messages.inspect.must_equal "{:username=>[\"can't be blank\"], :email=>[\"can't be blank\"]}"
+    end
+
+    # partially invalid.
+    # 2nd group fails.
+    it do
+      form.validate(password: 9).must_equal false
+      form.errors.messages.inspect.must_equal "{:username=>[\"can't be blank\"], :email=>[\"can't be blank\"]}"
+    end
+  end
+
+
+  # describe "overwriting a group" do
+  #   class OverwritingForm < Reform::Form
+  #     include Reform::Form::ActiveModel::Validations
+
+  #     property :username
+  #     property :email
+
+  #     validation :email do
+  #       validates :email, presence: true # is not considered, but overwritten.
+  #     end
+
+  #     validation :email do # overwrites the above.
+  #       validates :username, presence: true
+  #     end
+  #   end
+
+  #   let (:form) { OverwritingForm.new(Session.new) }
+
+  #   # valid.
+  #   it do
+  #     form.validate({username: "Helloween"}).must_equal true
+  #   end
+
+  #   # invalid.
+  #   it do
+  #     form.validate({}).must_equal false
+  #     form.errors.messages.inspect.must_equal "{:username=>[\"username can't be blank\"]}"
+  #   end
+  # end
+
+
+  describe "inherit: true in same group" do
+    class InheritSameGroupForm < Reform::Form
+      include Reform::Form::ActiveModel::Validations
+
+      property :username
+      property :email
+
+      validation :email do
+        validates :email, presence: true
+      end
+
+      validation :email, inherit: true do # extends the above.
+        validates :username, presence: true
+      end
+    end
+
+    let (:form) { InheritSameGroupForm.new(Session.new) }
+
+    # valid.
+    it do
+      form.validate({username: "Helloween", email: 9}).must_equal true
+    end
+
+    # invalid.
+    it do
+      form.validate({}).must_equal false
+      form.errors.messages.inspect.must_equal "{:email=>[\"can't be blank\"], :username=>[\"can't be blank\"]}"
+    end
+  end
+
+
+  describe "if: with lambda" do
+    class IfWithLambdaForm < Reform::Form
+      include Reform::Form::ActiveModel::Validations
+
+      property :username
+      property :email
+      property :password
+
+      validation :email do
+        validates :email, presence: true
+      end
+
+      # run this is :email group is true.
+      validation :after_email, if: lambda { |results| results[:email]==true } do # extends the above.
+        validates :username, presence: true
+      end
+
+      # block gets evaled in form instance context.
+      validation :password, if: lambda { |results| email == "john@trb.org" } do
+        validates :password, presence: true
+      end
+    end
+
+    let (:form) { IfWithLambdaForm.new(Session.new) }
+
+    # valid.
+    it do
+      form.validate({username: "Strung Out", email: 9}).must_equal true
+    end
+
+    # invalid.
+    it do
+      form.validate({email: 9}).must_equal false
+      form.errors.messages.inspect.must_equal "{:username=>[\"can't be blank\"]}"
+    end
+  end
+
+
+# TODO: describe "multiple errors for property" do
+
+  describe "::validate" do
+    class ValidateForm < Reform::Form
+      include Reform::Form::ActiveModel::Validations
+
+      property :username
+      validates :username, presence: true
+      validate :username_ok?#, context: :entity
+
+      def username_ok?#(value)
+        errors.add(:username, "not ok") if username == "yo"
+      end
+    end
+
+    let (:form) { ValidateForm.new(Session.new) }
+
+    # invalid.
+    it do
+      form.validate({username: "yo"}).must_equal false
+      form.errors.messages.inspect.must_equal "{:username=>[\"not ok\"]}"
+    end
+
+    # valid.
+    it do
+      form.validate({username: "not yo"}).must_equal true
+      form.errors.empty?.must_equal true
+    end
+  end
+
+
+  describe "validates: :acceptance" do
+    class AcceptanceForm < Reform::Form
+      property :accept, virtual: true, validates: { acceptance: true }
+    end
+
+    it { AcceptanceForm.new(nil).validate(accept: "0").must_equal false }
+    it { AcceptanceForm.new(nil).validate(accept: "1").must_equal true }
+  end
+end

data/test/validation/dry_validation_test.rb

@@ -0,0 +1,330 @@
+require "test_helper"
+require "reform/form/dry"
+
+class ValidationGroupsTest < MiniTest::Spec
+
+  describe "basic validations" do
+    Session = Struct.new(:username, :email, :password, :confirm_password)
+
+    class SessionForm < Reform::Form
+      include Reform::Form::Dry::Validations
+
+      property :username
+      property :email
+      property :password
+      property :confirm_password
+
+      validation :default do
+        key(:username, &:filled?)
+        key(:email, &:filled?)
+      end
+
+      validation :email, if: :default do
+        key(:email) do |email|
+          email.min_size?(3)
+        end
+      end
+
+      validation :nested, if: :default do
+        key(:password) do |password|
+          password.filled? & password.min_size?(2)
+        end
+      end
+
+      validation :confirm, if: :default, after: :email do
+        key(:confirm_password) do |confirm_password|
+          confirm_password.filled? & confirm_password.min_size?(2)
+        end
+      end
+    end
+
+    let (:form) { SessionForm.new(Session.new) }
+
+    # valid.
+    it do
+      form.validate({ username: "Helloween",
+                      email: "yep",
+                      password: "99",
+                      confirm_password: "99" }).must_equal true
+      form.errors.messages.inspect.must_equal "{}"
+    end
+
+    # invalid.
+    it do
+      form.validate({}).must_equal false
+      form.errors.messages.inspect.must_equal "{:username=>[\"username must be filled\"], :email=>[\"email must be filled\"]}"
+    end
+
+    # partially invalid.
+    # 2nd group fails.
+    it do
+      form.validate(username: "Helloween", email: "yo", confirm_password:"9").must_equal false
+      form.errors.messages.inspect.must_equal "{:email=>[\"email size cannot be less than 3\"], :confirm_password=>[\"confirm_password size cannot be less than 2\"], :password=>[\"password must be filled\"]}"
+    end
+    # 3rd group fails.
+    it do
+      form.validate(username: "Helloween", email: "yo!", confirm_password:"9").must_equal false
+      form.errors.messages.inspect
+        .must_equal "{:confirm_password=>[\"confirm_password size cannot be less than 2\"], :password=>[\"password must be filled\"]}"
+    end
+    # 4th group with after: fails.
+    it do
+      form.validate(username: "Helloween", email: "yo!", password: "", confirm_password: "9").must_equal false
+      form.errors.messages.inspect.must_equal "{:confirm_password=>[\"confirm_password size cannot be less than 2\"], :password=>[\"password must be filled\"]}"
+    end
+  end
+
+
+  describe "Nested validations" do
+    class AlbumForm < Reform::Form
+      include Reform::Form::Dry::Validations
+
+      property :title
+
+      property :hit do
+        property :title
+
+        # FIX ME: this doesn't work now, @apotonick said he knows why
+        #  The error is that this validation block act as an AM:V instead of the Dry one.
+        # validation :default do
+        #   key(:title, &:filled?)
+        # end
+      end
+
+      collection :songs do
+        property :title
+      end
+
+      property :band do
+        property :name
+        property :label do
+          property :name
+        end
+      end
+
+      validation :default do
+        configure { |config|
+          config.messages_file = 'test/fixtures/dry_error_messages.yml'
+        }
+
+        key(:title) do |title|
+          title.filled? & title.good_musical_taste?
+        end
+
+        key(:title, &:form_access_validation?)
+
+        # message need to be defined on fixtures/dry_error_messages
+        # d-v expects you to define your custome messages on the .yml file
+        def good_musical_taste?(value)
+          value != 'Nickelback'
+        end
+
+        def form_access_validation?(value)
+          form.title == 'Reform'
+        end
+      end
+    end
+
+    let (:album) do
+      OpenStruct.new(
+        :title  => "Blackhawks Over Los Angeles",
+        :hit    => song,
+        :songs  => songs,
+        :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) }
+
+    # correct #validate.
+    it do
+      result = form.validate(
+        "title"  => "Reform",
+        "songs"  => [
+                      {"title" => "Fallout"},
+                      {"title" => "Roxanne", "composer" => {"name" => "Sting"}}
+                    ],
+        "band"   => {"label" => {"name" => "Epitaph"}},
+      )
+
+      result.must_equal true
+      form.errors.messages.inspect.must_equal "{}"
+    end
+  end
+
+
+  describe "fails with :validate, :validates and :validates_with" do
+
+    it "throws a goddamn error" do
+      e = proc do
+        class FailingForm < Reform::Form
+          include Reform::Form::Dry::Validations
+
+          property :username
+
+          validation :email do
+            validates(:email, &:filled?)
+          end
+        end
+      end.must_raise
+      # e.message.must_equal 'validates() is not supported by Dry Validation backend.'
+
+      e = proc do
+        class FailingForm < Reform::Form
+          include Reform::Form::Dry::Validations
+
+          property :username
+
+          validation :email do
+            validate(:email, &:filled?)
+          end
+        end
+      end.must_raise(NoMethodError)
+      # e.message.must_equal 'validate() is not supported by Dry Validation backend.'
+
+      e = proc do
+        class FailingForm < Reform::Form
+          include Reform::Form::Dry::Validations
+
+          property :username
+
+          validation :email do
+            validates_with(:email, &:filled?)
+          end
+        end
+      end.must_raise
+      # e.message.must_equal 'validates_with() is not supported by Dry Validation backend.'
+    end
+  end
+
+
+  # describe "same-named group" do
+  #   class OverwritingForm < Reform::Form
+  #     include Reform::Form::Dry::Validations
+
+  #     property :username
+  #     property :email
+
+  #     validation :email do # FIX ME: is this working for other validator or just bugging here?
+  #       key(:email, &:filled?) # it's not considered, overitten
+  #     end
+
+  #     validation :email do # just another group.
+  #       key(:username, &:filled?)
+  #     end
+  #   end
+
+  #   let (:form) { OverwritingForm.new(Session.new) }
+
+  #   # valid.
+  #   it do
+  #     form.validate({username: "Helloween"}).must_equal true
+  #   end
+
+  #   # invalid.
+  #   it "whoo" do
+  #     form.validate({}).must_equal false
+  #     form.errors.messages.inspect.must_equal "{:username=>[\"username can't be blank\"]}"
+  #   end
+  # end
+
+
+  describe "inherit: true in same group" do
+    class InheritSameGroupForm < Reform::Form
+      include Reform::Form::Dry::Validations
+
+      property :username
+      property :email
+
+      validation :email do
+        key(:email, &:filled?)
+      end
+
+      validation :email, inherit: true do # extends the above.
+        key(:username, &:filled?)
+      end
+    end
+
+    let (:form) { InheritSameGroupForm.new(Session.new) }
+
+    # valid.
+    it do
+      form.validate({username: "Helloween", email: 9}).must_equal true
+    end
+
+    # invalid.
+    it do
+      form.validate({}).must_equal false
+      form.errors.messages.inspect.must_equal "{:email=>[\"email must be filled\"], :username=>[\"username must be filled\"]}"
+    end
+  end
+
+
+  describe "if: with lambda" do
+    class IfWithLambdaForm < Reform::Form
+      include Reform::Form::Dry::Validations # ::build_errors.
+
+      property :username
+      property :email
+      property :password
+
+      validation :email do
+        # validates :email, presence: true
+        key(:email, &:filled?)
+      end
+
+      # run this is :email group is true.
+      validation :after_email, if: lambda { |results| results[:email]==true } do # extends the above.
+        # validates :username, presence: true
+        key(:username, &:filled?)
+      end
+
+      # block gets evaled in form instance context.
+      validation :password, if: lambda { |results| email == "john@trb.org" } do
+        # validates :password, presence: true
+        key(:password, &:filled?)
+      end
+    end
+
+    let (:form) { IfWithLambdaForm.new(Session.new) }
+
+    # valid.
+    it do
+      form.validate({username: "Strung Out", email: 9}).must_equal true
+    end
+
+    # invalid.
+    it do
+      form.validate({email: 9}).must_equal false
+      form.errors.messages.inspect.must_equal "{:username=>[\"username must be filled\"]}"
+    end
+  end
+
+
+  # Currenty dry-v don't support that option, it doesn't make sense
+  #   I've talked to @solnic and he plans to add a "hint" feature to show
+  #   more errors messages than only those that have failed.
+  #
+  # describe "multiple errors for property" do
+  #   class MultipleErrorsForPropertyForm < Reform::Form
+  #     include Reform::Form::Dry::Validations
+
+  #     property :username
+
+  #     validation :default do
+  #       key(:username) do |username|
+  #         username.filled? | (username.min_size?(2) & username.max_size?(3))
+  #       end
+  #     end
+  #   end
+
+  #   let (:form) { MultipleErrorsForPropertyForm.new(Session.new) }
+
+  #   # valid.
+  #   it do
+  #     form.validate({username: ""}).must_equal false
+  #     form.errors.messages.inspect.must_equal "{:username=>[\"username must be filled\", \"username is not proper size\"]}"
+  #   end
+  # end
+end