reform 2.2.4 → 2.6.2

data/test/fixtures/dry_error_messages.yml

@@ -1,44 +1,104 @@
-array?: "%{name} must be an array"
+en:
+  dry_validation:
+    errors:
+      array?: "must be an array"
 
-empty?: "%{name} cannot be empty"
+      empty?: "must be empty"
 
-exclusion?: "%{name} must not be one of: %{list}"
+      excludes?: "must not include %{value}"
 
-eql?: "%{name} must be equal to %{eql_value}"
+      excluded_from?:
+        arg:
+          default: "must not be one of: %{list}"
+          range: "must not be one of: %{list_left} - %{list_right}"
 
-filled?: "%{name} must be filled"
+      eql?: "must be equal to %{left}"
 
-format?: "%{name} is in invalid format"
+      not_eql?: "must not be equal to %{left}"
 
-gt?: "%{name} must be greater than %{num} (%{value} was given)"
+      filled?: "must be filled"
 
-gteq?: "%{name} must be greater than or equal to %{num}"
+      format?: "is in invalid format"
 
-hash?: "%{name} must be a hash"
+      number?: "must be a number"
 
-inclusion?: "%{name} must be one of: %{list}"
+      odd?: "must be odd"
 
-int?: "%{name} must be an integer"
+      even?: "must be even"
 
-key?: "%{name} is missing"
+      gt?: "must be greater than %{num}"
 
-lt?: "%{name} must be less than %{num} (%{value} was given)"
+      gteq?: "must be greater than or equal to %{num}"
 
-lteq?: "%{name} must be less than or equal to %{num}"
+      hash?: "must be a hash"
 
-max_size?: "%{name} size cannot be greater than %{num}"
+      included_in?:
+        arg:
+          default: "must be one of: %{list}"
+          range: "must be one of: %{list_left} - %{list_right}"
 
-min_size?: "%{name} size cannot be less than %{num}"
+      includes?: "must include %{value}"
 
-nil?: "%{name} cannot be nil"
+      bool?: "must be boolean"
 
-size?:
-  range: "%{name} size must be within %{left} - %{right}"
-  default: "%{name} size must be %{num}"
+      true?: "must be true"
 
-str?: "%{name} must be a string"
+      false?: "must be false"
 
-good_musical_taste?: "you're a bad person"
+      int?: "must be an integer"
 
-form_access_validation?: "this doesn't look like a Reform form dude!!"
+      float?: "must be a float"
 
+      decimal?: "must be a decimal"
+
+      date?: "must be a date"
+
+      date_time?: "must be a date time"
+
+      time?: "must be a time"
+
+      key?: "is missing"
+
+      attr?: "is missing"
+
+      lt?: "must be less than %{num}"
+
+      lteq?: "must be less than or equal to %{num}"
+
+      max_size?: "size cannot be greater than %{num}"
+
+      min_size?: "size cannot be less than %{num}"
+
+      none?: "cannot be defined"
+
+      str?: "must be a string"
+
+      type?: "must be %{type}"
+
+      size?:
+        arg:
+          default: "size must be %{size}"
+          range: "size must be within %{size_left} - %{size_right}"
+
+        value:
+          string:
+            arg:
+              default: "length must be %{size}"
+              range: "length must be within %{size_left} - %{size_right}"
+
+
+
+      rules:
+        name:
+          good_musical_taste?: "you're a bad person"
+        title:
+          good_musical_taste?: "you're a bad person"
+        songs:
+          a_song?: "must have at least one enabled song"
+        artist:
+          with_last_name?: "must have last name"
+
+de:
+  dry_validation:
+    errors:
+      filled?: "muss abgefüllt sein"

data/test/form_option_test.rb

@@ -1,23 +1,23 @@
-require 'test_helper'
+require "test_helper"
 
 class FormOptionTest < MiniTest::Spec
   Song  = Struct.new(:title)
   Album = Struct.new(:song)
 
-  class SongForm < Reform::Form
+  class SongForm < TestForm
     property :title
     validation do
-      key(:title).required
+      params { required(:title).filled }
     end
   end
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :song, form: SongForm
   end
 
   it do
     form = AlbumForm.new(Album.new(Song.new("When It Comes To You")))
-    form.song.title.must_equal "When It Comes To You"
+    assert_equal "When It Comes To You", form.song.title
 
     form.validate(song: {title: "Run For Cover"})
   end

data/test/form_test.rb

@@ -1,9 +1,9 @@
-require 'test_helper'
+require "test_helper"
 
 class FormTest < MiniTest::Spec
   Artist = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :title
 
     property :hit do
@@ -22,11 +22,11 @@ class FormTest < MiniTest::Spec
   end
 
   describe "::dup" do
-    let (:cloned) { AlbumForm.clone }
+    let(:cloned) { AlbumForm.clone }
 
     # #dup is called in Op.inheritable_attr(:contract_class), it must be subclass of the original one.
-    it { cloned.wont_equal AlbumForm }
-    it { AlbumForm.definitions.wont_equal cloned.definitions }
+    it { refute_equal cloned, AlbumForm }
+    it { refute_equal AlbumForm.definitions, cloned.definitions }
 
     it do
       # currently, forms need a name for validation, even without AM.
@@ -37,7 +37,7 @@ class FormTest < MiniTest::Spec
       end
 
       cloned.validation do
-        key(:title).required
+        params { required(:title).filled }
       end
 
       cloned.new(OpenStruct.new).validate({})
@@ -45,13 +45,13 @@ class FormTest < MiniTest::Spec
   end
 
   describe "#initialize" do
-    class ArtistForm < Reform::Form
+    class ArtistForm < TestForm
       property :name
       property :current_user, virtual: true
     end
 
     it "allows injecting :virtual options" do
-      ArtistForm.new(Artist.new, current_user: Object).current_user.must_equal Object
+      assert_equal ArtistForm.new(Artist.new, current_user: Object).current_user, Object
     end
   end
 end

data/test/from_test.rb

@@ -1,7 +1,7 @@
-require 'test_helper'
+require "test_helper"
 
 class AsTest < BaseTest
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :name, from: :title
 
     property :single, from: :hit do
@@ -19,46 +19,42 @@ class AsTest < BaseTest
     end
   end
 
-  let (:song2) { Song.new("Roxanne") }
+  let(:song2) { Song.new("Roxanne") }
 
-  let (:params) {
+  let(:params) do
       {
         "name" => "Best Of The Police",
-        "single"   => {"title" => "So Lonely"},
+        "single" => {"title" => "So Lonely"},
         "tracks" => [{"name" => "Message In A Bottle"}, {"name" => "Roxanne"}]
       }
-    }
+    end
 
   subject { AlbumForm.new(Album.new("Best Of", hit, [Song.new("Fallout"), song2])) }
 
-  it { subject.name.must_equal "Best Of" }
-  it { subject.single.title.must_equal "Roxanne" }
-  it { subject.tracks[0].name.must_equal "Fallout" }
-  it { subject.tracks[1].name.must_equal "Roxanne" }
-
+  it { assert_equal subject.name, "Best Of" }
+  it { assert_equal subject.single.title, "Roxanne" }
+  it { assert_equal subject.tracks[0].name, "Fallout" }
+  it { assert_equal subject.tracks[1].name, "Roxanne" }
 
   describe "#validate" do
 
-
     before { subject.validate(params) }
 
-    it { subject.name.must_equal "Best Of The Police" }
-    it { subject.single.title.must_equal "So Lonely" }
-    it { subject.tracks[0].name.must_equal "Message In A Bottle" }
-    it { subject.tracks[1].name.must_equal "Roxanne" }
+    it { assert_equal subject.name, "Best Of The Police" }
+    it { assert_equal subject.single.title, "So Lonely" }
+    it { assert_equal subject.tracks[0].name, "Message In A Bottle" }
+    it { assert_equal subject.tracks[1].name, "Roxanne" }
   end
 
-
   describe "#sync" do
-    before {
+    before do
       subject.tracks[1].name = "Livin' Ain't No Crime"
       subject.sync
-    }
+    end
 
-    it { song2.title.must_equal "Livin' Ain't No Crime" }
+    it { assert_equal song2.title, "Livin' Ain't No Crime" }
   end
 
-
   describe "#save (nested hash)" do
     before { subject.validate(params) }
 
@@ -69,7 +65,7 @@ class AsTest < BaseTest
         hash = nested_hash
       end
 
-      hash.must_equal({"title"=>"Best Of The Police", "hit"=>{"title"=>"So Lonely"}, "songs"=>[{"title"=>"Message In A Bottle"}, {"title"=>"Roxanne"}]})
+      assert_equal hash, "title" => "Best Of The Police", "hit" => {"title" => "So Lonely"}, "songs" => [{"title" => "Message In A Bottle"}, {"title" => "Roxanne"}], "band" => nil
     end
   end
 end

data/test/inherit_test.rb

@@ -1,119 +1,105 @@
-require 'test_helper'
-require 'representable/json'
+require "test_helper"
+require "representable/json"
 
 class InheritTest < BaseTest
   Populator = Reform::Form::Populator
 
-  class AlbumForm < Reform::Form
+  class SkipParse
+    include Uber::Callable
+    def call(*_args)
+      false
+    end
+  end
+
+  class AlbumForm < TestForm
     property :title, deserializer: {instance: "Instance"}, skip_if: "skip_if in AlbumForm" # allow direct configuration of :deserializer.
 
-    property :hit, populator: "Populator" do
+    property :hit, populate_if_empty: ->(*) { Song.new } do
       property :title
+      validation do
+        params { required(:title).filled }
+      end
     end
 
-    collection :songs, populate_if_empty: lambda {}, skip_if: :all_blank do
+    collection :songs, populate_if_empty: -> {}, skip_if: :all_blank do
       property :title
     end
 
-    property :artist, populate_if_empty: lambda {} do
-
-      def artist_id
+    property :band, populate_if_empty: -> {} do
+      def band_id
         1
       end
     end
   end
 
-  puts
-  puts "inherit"
-
   class CompilationForm < AlbumForm
     property :title, inherit: true, skip_if: "skip_if from CompilationForm"
-    puts "[#{options_for(:title)[:deserializer].object_id}] COM@@@@@ #{options_for(:title)[:deserializer].inspect}"
-    # property :hit, :inherit => true do
-    #   property :rating
-    #   validates :title, :rating, :presence => true
-    # end
-
-    # puts representer_class.representable_attrs.
-    #   get(:hit)[:extend].evaluate(nil).new(OpenStruct.new).rating
+    property :hit, inherit: true, populate_if_empty: ->(*) { Song.new }, skip_if: SkipParse.new do
+      property :rating
+      validation do
+        params { required(:rating).filled }
+      end
+    end
 
     # NO collection here, this is entirely inherited.
-    # collection :songs, ..
-
-    property :artist, inherit: true do # inherit everything, but explicitely.
-    end
 
-    # completely override.
-    property :hit, skip_if: "SkipParse" do
+    property :band, inherit: true do # inherit everything, but explicitely.
     end
-
-    # override partly.
   end
 
-  let (:album) { Album.new(nil, OpenStruct.new(:hit => OpenStruct.new()) ) }
+  let(:album) { Album.new(nil, Song.new, [], Band.new) }
   subject { CompilationForm.new(album) }
 
+  it do
+    subject.validate("hit" => {"title" => "LA Drone", "rating" => 10})
+    assert_equal subject.hit.title, "LA Drone"
+    assert_equal subject.hit.rating, 10
+    assert_equal subject.errors.messages, {}
+  end
 
-  # valid.
-  # it {
-  #   subject.validate("hit" => {"title" => "LA Drone", "rating" => 10})
-  #   subject.hit.title.must_equal "LA Drone"
-  #   subject.hit.rating.must_equal 10
-  #   subject.errors.messages.must_equal({})
-  # }
-
-  # it do
-  #   subject.validate({})
-  #   subject.hit.title.must_equal nil
-  #   subject.hit.rating.must_equal nil
-  #   subject.errors.messages.must_equal({:"hit.title"=>["can't be blank"], :"hit.rating"=>["can't be blank"]})
-  # end
-
-require "pp"
+  it do
+    subject.validate({})
+    assert_nil subject.model.hit.title
+    assert_nil subject.model.hit.rating
+    assert_equal subject.errors.messages, "hit.title": ["must be filled"], "hit.rating": ["must be filled"]
+  end
 
   it "xxx" do
     # sub hashes like :deserializer must be properly cloned when inheriting.
-    AlbumForm.options_for(:title)[:deserializer].object_id.wont_equal CompilationForm.options_for(:title)[:deserializer].object_id
+    refute_equal AlbumForm.options_for(:title)[:deserializer].object_id, CompilationForm.options_for(:title)[:deserializer].object_id
 
     # don't overwrite direct deserializer: {} configuration.
-    AlbumForm.options_for(:title)[:internal_populator].must_be_instance_of Reform::Form::Populator::Sync
-    AlbumForm.options_for(:title)[:deserializer][:skip_parse].must_equal "skip_if in AlbumForm"
+    assert AlbumForm.options_for(:title)[:internal_populator].is_a? Reform::Form::Populator::Sync
+    assert_equal AlbumForm.options_for(:title)[:deserializer][:skip_parse], "skip_if in AlbumForm"
 
-    AlbumForm.options_for(:hit)[:internal_populator].inspect.must_match /Reform::Form::Populator:.+ @user_proc="Populator"/
+    # AlbumForm.options_for(:hit)[:internal_populator].inspect.must_match /Reform::Form::Populator:.+ @user_proc="Populator"/
     # AlbumForm.options_for(:hit)[:deserializer][:instance].inspect.must_be_instance_with Reform::Form::Populator, user_proc: "Populator"
 
+    assert AlbumForm.options_for(:songs)[:internal_populator].is_a? Reform::Form::Populator::IfEmpty
+    assert AlbumForm.options_for(:songs)[:deserializer][:skip_parse].is_a? Reform::Form::Validate::Skip::AllBlank
 
-    AlbumForm.options_for(:songs)[:internal_populator].must_be_instance_of Reform::Form::Populator::IfEmpty
-    AlbumForm.options_for(:songs)[:deserializer][:skip_parse].must_be_instance_of Reform::Form::Validate::Skip::AllBlank
-
-    AlbumForm.options_for(:artist)[:internal_populator].must_be_instance_of Reform::Form::Populator::IfEmpty
+    assert AlbumForm.options_for(:band)[:internal_populator].is_a? Reform::Form::Populator::IfEmpty
 
-
-
-    CompilationForm.options_for(:title)[:deserializer][:skip_parse].must_equal "skip_if from CompilationForm"
+    assert_equal CompilationForm.options_for(:title)[:deserializer][:skip_parse], "skip_if from CompilationForm"
     # pp CompilationForm.options_for(:songs)
-    CompilationForm.options_for(:songs)[:internal_populator].must_be_instance_of Reform::Form::Populator::IfEmpty
-
+    assert CompilationForm.options_for(:songs)[:internal_populator].is_a? Reform::Form::Populator::IfEmpty
 
-    CompilationForm.options_for(:artist)[:internal_populator].must_be_instance_of Reform::Form::Populator::IfEmpty
+    assert CompilationForm.options_for(:band)[:internal_populator].is_a? Reform::Form::Populator::IfEmpty
 
     # completely overwrite inherited.
-    CompilationForm.options_for(:hit)[:internal_populator].must_be_instance_of Reform::Form::Populator::Sync # reset to default.
-    CompilationForm.options_for(:hit)[:deserializer][:skip_parse].must_equal "SkipParse"
-
+    assert CompilationForm.options_for(:hit)[:deserializer][:skip_parse].is_a? SkipParse
 
     # inherit: true with block will still inherit the original class.
-    AlbumForm.new(OpenStruct.new(artist: OpenStruct.new)).artist.artist_id.must_equal 1
-    CompilationForm.new(OpenStruct.new(artist: OpenStruct.new)).artist.artist_id.must_equal 1
+    assert_equal AlbumForm.new(OpenStruct.new(band: OpenStruct.new)).band.band_id, 1
+    assert_equal CompilationForm.new(OpenStruct.new(band: OpenStruct.new)).band.band_id, 1
   end
 
-
   class CDForm < AlbumForm
-    # override :artist's original populate_if_empty but with :inherit.
-    property :artist, inherit: true, populator: "CD Populator" do
+    # override :band's original populate_if_empty but with :inherit.
+    property :band, inherit: true, populator: "CD Populator" do
 
     end
   end
 
-  it { CDForm.options_for(:artist)[:internal_populator].instance_variable_get(:@user_proc).must_equal "CD Populator" }
-end
+  it { assert_equal CDForm.options_for(:band)[:internal_populator].instance_variable_get(:@user_proc), "CD Populator" }
+end

data/test/module_test.rb

@@ -1,5 +1,5 @@
 require "test_helper"
-require 'reform/form/coercion'
+require "reform/form/coercion"
 
 class ModuleInclusionTest < MiniTest::Spec
   module BandPropertyForm
@@ -9,7 +9,7 @@ class ModuleInclusionTest < MiniTest::Spec
       property :title
 
       validation do
-        key(:title).required
+        params { required(:title).filled }
       end
 
       def id # gets mixed into Form, too.
@@ -22,11 +22,11 @@ class ModuleInclusionTest < MiniTest::Spec
     end
 
     validation do
-      key(:band).required
+      params { required(:band).filled }
     end
 
-    include Dry::Types.module # allows using Types::* in module.
-    property :cool, type: Form::Bool # test coercion.
+    include Dry.Types(default: :nominal) # allows using Types::* in module.
+    property :cool, type: Types::Params::Bool # test coercion.
   end
 
   # TODO: test if works, move stuff into inherit_schema!
@@ -36,53 +36,50 @@ class ModuleInclusionTest < MiniTest::Spec
     collection :airplays do
       property :station
       validation do
-        key(:station).required
+        params { required(:station).filled }
       end
     end
     validation do
-      key(:airplays).required
+      params { required(:airplays).filled }
     end
   end
 
-
   # test:
   # by including BandPropertyForm into multiple classes we assure that options hashes don't get messed up by AM:V.
-  class HitForm < Reform::Form
+  class HitForm < TestForm
     include BandPropertyForm
   end
 
-  class SongForm < Reform::Form
+  class SongForm < TestForm
     include Coercion
     property :title
 
     include BandPropertyForm
   end
 
-
-  let (:song) { OpenStruct.new(:band => OpenStruct.new(:title => "Time Again")) }
+  let(:song) { OpenStruct.new(band: OpenStruct.new(title: "Time Again")) }
 
   # nested form from module is present and creates accessor.
-  it { SongForm.new(song).band.title.must_equal "Time Again" }
+  it { assert_equal SongForm.new(song).band.title, "Time Again" }
 
   # methods from module get included.
-  it { SongForm.new(song).id.must_equal 1 }
-  it { SongForm.new(song).band.id.must_equal 2 }
+  it { assert_equal SongForm.new(song).id, 1 }
+  it { assert_equal SongForm.new(song).band.id, 2 }
 
   # validators get inherited.
   it do
     form = SongForm.new(OpenStruct.new)
     form.validate({})
-    form.errors.messages.must_equal({:band=>["is missing"]})
+    assert_equal form.errors.messages, band: ["must be filled"]
   end
 
   # coercion works
   it do
     form = SongForm.new(OpenStruct.new)
-    form.validate({cool: "1"})
-    form.cool.must_equal true
+    form.validate(cool: "1")
+    assert form.cool
   end
 
-
   # include a module into a module into a class :)
   module AlbumFormModule
     include Reform::Form::Module
@@ -90,29 +87,28 @@ class ModuleInclusionTest < MiniTest::Spec
 
     property :name
     validation do
-      key(:name).required
+      params { required(:name).filled }
     end
   end
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     include AlbumFormModule
 
     # pp heritage
-    property :band, :inherit => true do
+    property :band, inherit: true do
       property :label
       validation do
-        key(:label).required
+        params { required(:label).filled }
       end
     end
   end
 
   it do
-    form = AlbumForm.new(OpenStruct.new(:band => OpenStruct.new))
-    form.validate({"band" => {}})
-    form.errors.messages.must_equal({:band=>["must be filled"], :"band.title"=>["is missing"], :"band.label"=>["is missing"], :name=>["is missing"]})
+    form = AlbumForm.new(OpenStruct.new(band: OpenStruct.new))
+    form.validate("band" => {})
+    assert_equal form.errors.messages, "band.title": ["must be filled"], "band.label": ["must be filled"], name: ["must be filled"]
   end
 
-
   describe "module with custom accessors" do
     module SongModule
       include Reform::Form::Module
@@ -127,16 +123,15 @@ class ModuleInclusionTest < MiniTest::Spec
       end
     end
 
-    class IncludingSongForm < Reform::Form
+    class IncludingSongForm < TestForm
       include SongModule
     end
 
-    let (:song) { OpenStruct.new(id: 1, title: "Instant Mash") }
+    let(:song) { OpenStruct.new(id: 1, title: "Instant Mash") }
 
     it do
-      IncludingSongForm.new(song).id.must_equal 1
-      IncludingSongForm.new(song).title.must_equal "INSTANT MASH"
+      assert_equal IncludingSongForm.new(song).id, 1
+      assert_equal IncludingSongForm.new(song).title, "INSTANT MASH"
     end
   end
 end
-

data/test/parse_option_test.rb

@@ -0,0 +1,40 @@
+require "test_helper"
+
+class ParseOptionTest < MiniTest::Spec
+  Comment = Struct.new(:content, :user)
+  User    = Struct.new(:name)
+
+  class CommentForm < TestForm
+    property :content
+    property :user, parse: false
+  end
+
+  let(:current_user) { User.new("Peter") }
+  let(:form) { CommentForm.new(Comment.new, user: current_user) }
+
+  it do
+    assert_equal form.user, current_user
+
+    lorem = "Lorem ipsum dolor sit amet..."
+    form.validate("content" => lorem, "user" => "not the current user")
+
+    assert_equal form.content, lorem
+    assert_equal form.user, current_user
+  end
+
+  describe "using ':parse' option doesn't override other ':deserialize' options" do
+    class ArticleCommentForm < TestForm
+      property :content
+      property :article, deserializer: {instance: "Instance"}
+      property :user, parse: false, deserializer: {instance: "Instance"}
+    end
+
+    it do
+      assert_equal ArticleCommentForm.definitions.get(:user)[:deserializer][:writeable], false
+      assert_equal ArticleCommentForm.definitions.get(:user)[:deserializer][:instance], "Instance"
+
+      assert ArticleCommentForm.definitions.get(:article)[:deserializer][:writeable]
+      assert_equal ArticleCommentForm.definitions.get(:article)[:deserializer][:instance], "Instance"
+    end
+  end
+end