reform 2.3.3 → 2.5.0

data/test/fixtures/dry_new_api_error_messages.yml

@@ -1,104 +0,0 @@
-en:
-  dry_validation:
-    errors:
-      array?: "must be an array"
-
-      empty?: "must be empty"
-
-      excludes?: "must not include %{value}"
-
-      excluded_from?:
-        arg:
-          default: "must not be one of: %{list}"
-          range: "must not be one of: %{list_left} - %{list_right}"
-
-      eql?: "must be equal to %{left}"
-
-      not_eql?: "must not be equal to %{left}"
-
-      filled?: "must be filled"
-
-      format?: "is in invalid format"
-
-      number?: "must be a number"
-
-      odd?: "must be odd"
-
-      even?: "must be even"
-
-      gt?: "must be greater than %{num}"
-
-      gteq?: "must be greater than or equal to %{num}"
-
-      hash?: "must be a hash"
-
-      included_in?:
-        arg:
-          default: "must be one of: %{list}"
-          range: "must be one of: %{list_left} - %{list_right}"
-
-      includes?: "must include %{value}"
-
-      bool?: "must be boolean"
-
-      true?: "must be true"
-
-      false?: "must be false"
-
-      int?: "must be an integer"
-
-      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_old_api.rb

@@ -1,57 +0,0 @@
-require "test_helper"
-
-class FormTest < MiniTest::Spec
-  Artist = Struct.new(:name)
-
-  class AlbumForm < TestForm
-    property :title
-
-    property :hit do
-      property :title
-    end
-
-    collection :songs do
-      property :title
-    end
-
-    property :band do # yepp, people do crazy stuff like that.
-      property :label do
-        property :name
-      end
-    end
-  end
-
-  describe "::dup" do
-    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 do
-      # currently, forms need a name for validation, even without AM.
-      cloned.singleton_class.class_eval do
-        def name
-          "Album"
-        end
-      end
-
-      cloned.validation do
-        required(:title).filled
-      end
-
-      cloned.new(OpenStruct.new).validate({})
-    end
-  end
-
-  describe "#initialize" do
-    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
-    end
-  end
-end

data/test/form_option_old_api.rb

@@ -1,24 +0,0 @@
-require "test_helper"
-
-class FormOptionTest < MiniTest::Spec
-  Song  = Struct.new(:title)
-  Album = Struct.new(:song)
-
-  class SongForm < TestForm
-    property :title
-    validation do
-      required(:title).filled
-    end
-  end
-
-  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"
-
-    form.validate(song: {title: "Run For Cover"})
-  end
-end

data/test/inherit_old_api.rb

@@ -1,105 +0,0 @@
-require "test_helper"
-require "representable/json"
-
-class InheritTest < BaseTest
-  Populator = Reform::Form::Populator
-
-  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, populate_if_empty: ->(*) { Song.new } do
-      property :title
-      validation do
-        required(:title).filled
-      end
-    end
-
-    collection :songs, populate_if_empty: -> {}, skip_if: :all_blank do
-      property :title
-    end
-
-    property :band, populate_if_empty: -> {} do
-      def band_id
-        1
-      end
-    end
-  end
-
-  class CompilationForm < AlbumForm
-    property :title, inherit: true, skip_if: "skip_if from CompilationForm"
-    property :hit, inherit: true, populate_if_empty: ->(*) { Song.new }, skip_if: SkipParse.new do
-      property :rating
-      validation do
-        required(:rating).filled
-      end
-    end
-
-    # NO collection here, this is entirely inherited.
-
-    property :band, inherit: true do # inherit everything, but explicitely.
-    end
-  end
-
-  let(:album) { Album.new(nil, Song.new, [], Band.new) }
-  subject { CompilationForm.new(album) }
-
-  it do
-    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({})
-  end
-
-  it do
-    subject.validate({})
-    assert_nil subject.model.hit.title
-    assert_nil subject.model.hit.rating
-    _(subject.errors.messages).must_equal("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
-
-    # 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"
-
-    # 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"
-
-    _(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(:band)[:internal_populator]).must_be_instance_of Reform::Form::Populator::IfEmpty
-
-    _(CompilationForm.options_for(:title)[:deserializer][:skip_parse]).must_equal "skip_if from CompilationForm"
-    # pp CompilationForm.options_for(:songs)
-    _(CompilationForm.options_for(:songs)[:internal_populator]).must_be_instance_of Reform::Form::Populator::IfEmpty
-
-    _(CompilationForm.options_for(:band)[:internal_populator]).must_be_instance_of Reform::Form::Populator::IfEmpty
-
-    # completely overwrite inherited.
-    _(CompilationForm.options_for(:hit)[:deserializer][:skip_parse]).must_be_instance_of SkipParse
-
-    # inherit: true with block will still inherit the original class.
-    _(AlbumForm.new(OpenStruct.new(band: OpenStruct.new)).band.band_id).must_equal 1
-    _(CompilationForm.new(OpenStruct.new(band: OpenStruct.new)).band.band_id).must_equal 1
-  end
-
-  class CDForm < AlbumForm
-    # override :band's original populate_if_empty but with :inherit.
-    property :band, inherit: true, populator: "CD Populator" do
-
-    end
-  end
-
-  it { _(CDForm.options_for(:band)[:internal_populator].instance_variable_get(:@user_proc)).must_equal "CD Populator" }
-end

data/test/module_old_api.rb

@@ -1,146 +0,0 @@
-require "test_helper"
-require "reform/form/coercion"
-
-class ModuleInclusionTest < MiniTest::Spec
-  module BandPropertyForm
-    include Reform::Form::Module
-
-    property :artist
-    property :band do
-      property :title
-
-      validation do
-        required(:title).filled
-      end
-
-      def id # gets mixed into Form, too.
-        2
-      end
-    end
-
-    def id # gets mixed into Form, too.
-      1
-    end
-
-    validation do
-      required(:band).filled
-    end
-
-    include Dry::Types.module # allows using Types::* in module.
-    property :cool, type: DRY_TYPES_CONSTANT::Bool # test coercion.
-
-    module InstanceMethods
-      def artist=(new_value)
-        errors.add(:artist, "this needs to be filled") if new_value.nil?
-        super(new_value)
-      end
-    end
-  end
-
-  # TODO: test if works, move stuff into inherit_schema!
-  module AirplaysPropertyForm
-    include Reform::Form::Module
-
-    collection :airplays do
-      property :station
-      validation do
-        required(:station).filled
-      end
-    end
-    validation do
-      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 < TestForm
-    include BandPropertyForm
-  end
-
-  class SongForm < TestForm
-    include Coercion
-    property :title
-
-    include BandPropertyForm
-  end
-
-  let(:song) { OpenStruct.new(band: OpenStruct.new(title: "Time Again"), artist: "Ketama") }
-
-  # nested form from module is present and creates accessor.
-  it { _(SongForm.new(song).band.title).must_equal "Time Again" }
-  it { _(SongForm.new(song).artist).must_equal "Ketama" }
-
-  # methods from module get included.
-  it { _(SongForm.new(song).id).must_equal 1 }
-  it { _(SongForm.new(song).band.id).must_equal 2 }
-
-  # validators get inherited.
-  it do
-    form = SongForm.new(OpenStruct.new)
-    form.validate(artist: nil)
-    _(form.errors.messages).must_equal(artist: ["this needs to be filled"], band: ["must be filled"])
-  end
-
-  # coercion works
-  it do
-    form = SongForm.new(OpenStruct.new)
-    form.validate({cool: "1"})
-    _(form.cool).must_equal true
-  end
-
-  # include a module into a module into a class :)
-  module AlbumFormModule
-    include Reform::Form::Module
-    include BandPropertyForm
-
-    property :name
-    validation do
-      required(:name).filled
-    end
-  end
-
-  class AlbumForm < TestForm
-    include AlbumFormModule
-
-    # pp heritage
-    property :band, inherit: true do
-      property :label
-      validation do
-        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.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
-
-      property :id    # no custom accessor for id.
-      property :title # has custom accessor.
-
-      module InstanceMethods
-        def title
-          super.upcase
-        end
-      end
-    end
-
-    class IncludingSongForm < TestForm
-      include SongModule
-    end
-
-    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"
-    end
-  end
-end

data/test/populate_old_api.rb

@@ -1,304 +0,0 @@
-require "test_helper"
-
-class PopulatorTest < MiniTest::Spec
-  Song  = Struct.new(:title, :album, :composer)
-  Album = Struct.new(:name, :songs, :artist)
-  Artist = Struct.new(:name)
-
-  class AlbumForm < TestForm
-    property :name, populator: ->(options) { self.name = options[:fragment].reverse }
-    validation do
-      required(:name).filled
-    end
-
-    collection :songs,
-               populator: ->(fragment:, model:, index:, **) {
-                 (item = model[index]) ? item : model.insert(index, Song.new)
-               } do
-      property :title
-      validation do
-        required(:title).filled
-      end
-
-      property :composer, populator: ->(options) { options[:model] || self.composer = Artist.new } do
-        property :name
-        validation do
-          required(:name).filled
-        end
-      end
-    end
-
-    # property :artist, populator: lambda { |fragment, options| (item = options.binding.get) ? item : Artist.new } do
-    # NOTE: we have to document that model here is the twin!
-    property :artist, populator: ->(options) { options[:model] || self.artist = Artist.new } do
-      property :name
-    end
-  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) }
-
-  let(:form) { AlbumForm.new(album) }
-
-  it "runs populator on scalar" do
-    form.validate(
-      "name" => "override me!"
-    )
-
-    _(form.name).must_equal "!em edirrevo"
-  end
-
-  # changing existing property :artist.
-  # TODO: check with artist==nil
-  it do
-    old_id = artist.object_id
-
-    form.validate(
-      "artist" => {"name" => "Marcus Miller"}
-    )
-
-    _(form.artist.model.object_id).must_equal old_id
-  end
-
-  # use populator for default value on scalars?
-
-  # adding to collection via :populator.
-  # valid.
-  it "yyy" do
-    _(form.validate(
-      "songs"  => [{"title" => "Fallout"}, {"title" => "Roxanne"},
-        {"title" => "Rime Of The Ancient Mariner"}, # new song.
-        {"title" => "Re-Education", "composer" => {"name" => "Rise Against"}}], # new song with new composer.
-    )).must_equal true
-
-    _(form.errors.messages.inspect).must_equal "{}"
-
-    # form has updated.
-    _(form.name).must_equal "The Dissent Of Man"
-    _(form.songs[0].title).must_equal "Fallout"
-    _(form.songs[1].title).must_equal "Roxanne"
-    _(form.songs[1].composer.name).must_equal "Greg Graffin"
-
-    _(form.songs[1].composer.model).must_be_instance_of Artist
-
-    _(form.songs[1].title).must_equal "Roxanne"
-    _(form.songs[2].title).must_equal "Rime Of The Ancient Mariner" # new song added.
-    _(form.songs[3].title).must_equal "Re-Education"
-    _(form.songs[3].composer.name).must_equal "Rise Against"
-    _(form.songs.size).must_equal 4
-    _(form.artist.name).must_equal "Bad Religion"
-
-    # model has not changed, yet.
-    _(album.name).must_equal "The Dissent Of Man"
-    _(album.songs[0].title).must_equal "Broken"
-    _(album.songs[1].title).must_equal "Resist Stance"
-    _(album.songs[1].composer.name).must_equal "Greg Graffin"
-    _(album.songs.size).must_equal 2
-    _(album.artist.name).must_equal "Bad Religion"
-  end
-end
-
-class PopulateWithMethodTest < Minitest::Spec
-  Album = Struct.new(:title)
-
-  class AlbumForm < TestForm
-    property :title, populator: :title!
-
-    def title!(options)
-      self.title = options[:fragment].reverse
-    end
-  end
-
-  let(:form) { AlbumForm.new(Album.new) }
-
-  it "runs populator method" do
-    form.validate("title" => "override me!")
-
-    _(form.title).must_equal "!em edirrevo"
-  end
-end
-
-class PopulateWithCallableTest < Minitest::Spec
-  Album = Struct.new(:title)
-
-  class TitlePopulator
-    include Uber::Callable
-
-    def call(form, options)
-      form.title = options[:fragment].reverse
-    end
-  end
-
-  class AlbumForm < TestForm
-    property :title, populator: TitlePopulator.new
-  end
-
-  let(:form) { AlbumForm.new(Album.new) }
-
-  it "runs populator method" do
-    form.validate("title" => "override me!")
-
-    _(form.title).must_equal "!em edirrevo"
-  end
-end
-
-class PopulateWithProcTest < Minitest::Spec
-  Album = Struct.new(:title)
-
-  TitlePopulator = ->(options) do
-    options[:represented].title = options[:fragment].reverse
-  end
-
-  class AlbumForm < TestForm
-    property :title, populator: TitlePopulator
-  end
-
-  let(:form) { AlbumForm.new(Album.new) }
-
-  it "runs populator method" do
-    form.validate("title" => "override me!")
-
-    _(form.title).must_equal "!em edirrevo"
-  end
-end
-
-class PopulateIfEmptyTest < MiniTest::Spec
-  Song  = Struct.new(:title, :album, :composer)
-  Album = Struct.new(:name, :songs, :artist)
-  Artist = Struct.new(:name)
-
-  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) }
-
-  class AlbumForm < TestForm
-    property :name
-
-    collection :songs,
-      populate_if_empty: Song do                                                # class name works.
-
-      property :title
-      validation do
-        required(:title).filled
-      end
-
-      property :composer, populate_if_empty: :populate_composer! do # lambda works, too. in form context.
-        property :name
-        validation do
-          required(:name).filled
-        end
-      end
-
-    private
-      def populate_composer!(options)
-        Artist.new
-      end
-    end
-
-    property :artist, populate_if_empty: ->(args) { create_artist(args[:fragment], args[:user_options]) } do # methods work, too.
-      property :name
-    end
-
-    private
-    class Sting < Artist
-      attr_accessor :args
-    end
-    def create_artist(input, user_options)
-      Sting.new.tap { |artist| artist.args = ([input, user_options].to_s) }
-    end
-  end
-
-  let(:form) { AlbumForm.new(album) }
-
-  it do
-    _(form.songs.size).must_equal 2
-
-    _(form.validate(
-      "songs" => [{"title" => "Fallout"}, {"title" => "Roxanne"},
-        {"title" => "Rime Of The Ancient Mariner"}, # new song.
-        {"title" => "Re-Education", "composer" => {"name" => "Rise Against"}}], # new song with new composer.
-    )).must_equal true
-
-    _(form.errors.messages.inspect).must_equal "{}"
-
-    # form has updated.
-    _(form.name).must_equal "The Dissent Of Man"
-    _(form.songs[0].title).must_equal "Fallout"
-    _(form.songs[1].title).must_equal "Roxanne"
-    _(form.songs[1].composer.name).must_equal "Greg Graffin"
-    _(form.songs[1].title).must_equal "Roxanne"
-    _(form.songs[2].title).must_equal "Rime Of The Ancient Mariner" # new song added.
-    _(form.songs[3].title).must_equal "Re-Education"
-    _(form.songs[3].composer.name).must_equal "Rise Against"
-    _(form.songs.size).must_equal 4
-    _(form.artist.name).must_equal "Bad Religion"
-
-    # model has not changed, yet.
-    _(album.name).must_equal "The Dissent Of Man"
-    _(album.songs[0].title).must_equal "Broken"
-    _(album.songs[1].title).must_equal "Resist Stance"
-    _(album.songs[1].composer.name).must_equal "Greg Graffin"
-    _(album.songs.size).must_equal 2
-    _(album.artist.name).must_equal "Bad Religion"
-  end
-
-  # trigger artist populator. lambda calling form instance method.
-  it "xxxx" do
-    form = AlbumForm.new(album = Album.new)
-    form.validate("artist" => {"name" => "From Autumn To Ashes"})
-
-    _(form.artist.name).must_equal "From Autumn To Ashes"
-    # test lambda was executed in form context.
-    _(form.artist.model).must_be_instance_of AlbumForm::Sting
-    # test lambda block arguments.
-    _(form.artist.model.args.to_s).must_equal "[{\"name\"=>\"From Autumn To Ashes\"}, nil]"
-
-    assert_nil album.artist
-  end
-end
-
-# delete songs while deserializing.
-class PopulateIfEmptyWithDeletionTest < MiniTest::Spec
-  Song  = Struct.new(:title, :album, :composer)
-  Album = Struct.new(:name, :songs, :artist)
-
-  let(:song)  { Song.new("Broken") }
-  let(:song2) { Song.new("Resist Stance") }
-  let(:album) { Album.new("The Dissent Of Man", [song, song2]) }
-
-  class AlbumForm < TestForm
-    property :name
-
-    collection :songs,
-      populate_if_empty: Song, skip_if: :delete_song! do
-
-      property :title
-      validation do
-        required(:title).filled
-      end
-    end
-
-    def delete_song!(options)
-      songs.delete(songs[0]) and return true if options[:fragment]["title"] == "Broken, delete me!"
-      false
-    end
-  end
-
-  let(:form) { AlbumForm.new(album) }
-
-  it do
-    _(form.validate(
-      "songs" => [{"title" => "Broken, delete me!"}, {"title" => "Roxanne"}]
-    )).must_equal true
-
-    _(form.errors.messages.inspect).must_equal "{}"
-
-    _(form.songs.size).must_equal 1
-    _(form.songs[0].title).must_equal "Roxanne"
-  end
-end